#! /usr/bin/env tclsh
# Crossword.tcl - R.Metcalfe May 2009 ...		

package require Tcl

package require Tk
# http.tcl --
#
#	Client-side HTTP for GET, POST, and HEAD commands. These routines can
#	be used in untrusted code that uses the Safesock security policy. These
#	procedures use a callback interface to avoid using vwait, which is not
#	defined in the safe base.
#
# See the file "license.terms" for information on usage and redistribution of
# this file, and for a DISCLAIMER OF ALL WARRANTIES.
#
# RCS: @(#) $Id: http.tcl,v 1.67.2.5 2008/10/23 23:34:32 patthoyts Exp $

package require Tcl 8.4
# Keep this in sync with pkgIndex.tcl and with the install directories
# in Makefiles
package provide http 2.7.2

namespace eval http {
    # Allow resourcing to not clobber existing data

    variable http
    if {![info exists http]} {
	array set http {
	    -accept */*
	    -proxyhost {}
	    -proxyport {}
	    -proxyfilter http::ProxyRequired
	    -urlencoding utf-8
	}
	set http(-useragent) "Tcl http client package [package provide http]"
    }

    proc init {} {
	# Set up the map for quoting chars. RFC3986 Section 2.3 say percent
	# encode all except: "... percent-encoded octets in the ranges of ALPHA
	# (%41-%5A and %61-%7A), DIGIT (%30-%39), hyphen (%2D), period (%2E),
	# underscore (%5F), or tilde (%7E) should not be created by URI
	# producers ..."
	for {set i 0} {$i <= 256} {incr i} {
	    set c [format %c $i]
	    if {![string match {[-._~a-zA-Z0-9]} $c]} {
		set map($c) %[format %.2x $i]
	    }
	}
	# These are handled specially
	set map(\n) %0d%0a
	variable formMap [array get map]

	# Create a map for HTTP/1.1 open sockets
	variable socketmap
	if {[info exists socketmap]} {
	    # Close but don't remove open sockets on re-init
	    foreach {url sock} [array get socketmap] {
		catch {close $sock}
	    }
	}
	array set socketmap {}
    }
    init

    variable urlTypes
    if {![info exists urlTypes]} {
	set urlTypes(http) [list 80 ::socket]
    }

    variable encodings [string tolower [encoding names]]
    # This can be changed, but iso8859-1 is the RFC standard.
    variable defaultCharset
    if {![info exists defaultCharset]} {
	set defaultCharset "iso8859-1"
    }

    # Force RFC 3986 strictness in geturl url verification?
    variable strict
    if {![info exists strict]} {
	set strict 1
    }

    # Let user control default keepalive for compatibility
    variable defaultKeepalive
    if {![info exists defaultKeepalive]} {
	set defaultKeepalive 0
    }

    namespace export geturl config reset wait formatQuery register unregister
    # Useful, but not exported: data size status code
}

# http::Log --
#
#	Debugging output -- define this to observe HTTP/1.1 socket usage.
#	Should echo any args received.
#
# Arguments:
#     msg	Message to output
#
proc http::Log {args} {}

# http::register --
#
#     See documentation for details.
#
# Arguments:
#     proto           URL protocol prefix, e.g. https
#     port            Default port for protocol
#     command         Command to use to create socket
# Results:
#     list of port and command that was registered.

proc http::register {proto port command} {
    variable urlTypes
    set urlTypes($proto) [list $port $command]
}

# http::unregister --
#
#     Unregisters URL protocol handler
#
# Arguments:
#     proto           URL protocol prefix, e.g. https
# Results:
#     list of port and command that was unregistered.

proc http::unregister {proto} {
    variable urlTypes
    if {![info exists urlTypes($proto)]} {
	return -code error "unsupported url type \"$proto\""
    }
    set old $urlTypes($proto)
    unset urlTypes($proto)
    return $old
}

# http::config --
#
#	See documentation for details.
#
# Arguments:
#	args		Options parsed by the procedure.
# Results:
#        TODO

proc http::config {args} {
    variable http
    set options [lsort [array names http -*]]
    set usage [join $options ", "]
    if {[llength $args] == 0} {
	set result {}
	foreach name $options {
	    lappend result $name $http($name)
	}
	return $result
    }
    set options [string map {- ""} $options]
    set pat ^-([join $options |])$
    if {[llength $args] == 1} {
	set flag [lindex $args 0]
	if {[regexp -- $pat $flag]} {
	    return $http($flag)
	} else {
	    return -code error "Unknown option $flag, must be: $usage"
	}
    } else {
	foreach {flag value} $args {
	    if {[regexp -- $pat $flag]} {
		set http($flag) $value
	    } else {
		return -code error "Unknown option $flag, must be: $usage"
	    }
	}
    }
}

# http::Finish --
#
#	Clean up the socket and eval close time callbacks
#
# Arguments:
#	token	    Connection token.
#	errormsg    (optional) If set, forces status to error.
#       skipCB      (optional) If set, don't call the -command callback. This
#                   is useful when geturl wants to throw an exception instead
#                   of calling the callback. That way, the same error isn't
#                   reported to two places.
#
# Side Effects:
#        Closes the socket

proc http::Finish { token {errormsg ""} {skipCB 0}} {
    variable $token
    upvar 0 $token state
    global errorInfo errorCode
    if {$errormsg ne ""} {
	set state(error) [list $errormsg $errorInfo $errorCode]
	set state(status) "error"
    }
    if {($state(status) eq "timeout") || ($state(status) eq "error")
        || ([info exists state(connection)] && ($state(connection) eq "close"))
    } {
        CloseSocket $state(sock) $token
    }
    if {[info exists state(after)]} { after cancel $state(after) }
    if {[info exists state(-command)] && !$skipCB} {
	if {[catch {eval $state(-command) {$token}} err]} {
	    if {$errormsg eq ""} {
		set state(error) [list $err $errorInfo $errorCode]
		set state(status) error
	    }
	}
	# Command callback may already have unset our state
	unset -nocomplain state(-command)
    }
}

# http::CloseSocket -
#
#	Close a socket and remove it from the persistent sockets table.
#	If possible an http token is included here but when we are called
#	from a fileevent on remote closure we need to find the correct
#	entry - hence the second section.

proc ::http::CloseSocket {s {token {}}} {
    variable socketmap
    catch {fileevent $s readable {}}
    set conn_id {}
    if {$token ne ""} {
        variable $token
        upvar 0 $token state
        if {[info exists state(socketinfo)]} {
            set conn_id $state(socketinfo)
        }
    } else {
        set map [array get socketmap]
        set ndx [lsearch -exact $map $s]
        if {$ndx != -1} {
            incr ndx -1
            set conn_id [lindex $map $ndx]
        }
    }
    if {$conn_id eq {} || ![info exists socketmap($conn_id)]} {
        Log "Closing socket $s (no connection info)"
        if {[catch {close $s} err]} { Log "Error: $err" }
    } else {
	if {[info exists socketmap($conn_id)]} {
	    Log "Closing connection $conn_id (sock $socketmap($conn_id))"
	    if {[catch {close $socketmap($conn_id)} err]} { Log "Error: $err" }
	    unset socketmap($conn_id)
	} else {
	    Log "Cannot close connection $conn_id - no socket in socket map"
	}
    }
}

# http::reset --
#
#	See documentation for details.
#
# Arguments:
#	token	Connection token.
#	why	Status info.
#
# Side Effects:
#       See Finish

proc http::reset { token {why reset} } {
    variable $token
    upvar 0 $token state
    set state(status) $why
    catch {fileevent $state(sock) readable {}}
    catch {fileevent $state(sock) writable {}}
    Finish $token
    if {[info exists state(error)]} {
	set errorlist $state(error)
	unset state
	eval ::error $errorlist
    }
}

# http::geturl --
#
#	Establishes a connection to a remote url via http.
#
# Arguments:
#       url		The http URL to goget.
#       args		Option value pairs. Valid options include:
#				-blocksize, -validate, -headers, -timeout
# Results:
#	Returns a token for this connection. This token is the name of an array
#	that the caller should unset to garbage collect the state.

proc http::geturl { url args } {
    variable http
    variable urlTypes
    variable defaultCharset
    variable defaultKeepalive
    variable strict

    # Initialize the state variable, an array. We'll return the name of this
    # array as the token for the transaction.

    if {![info exists http(uid)]} {
	set http(uid) 0
    }
    set token [namespace current]::[incr http(uid)]
    variable $token
    upvar 0 $token state
    reset $token

    # Process command options.

    array set state {
	-binary		false
	-blocksize	8192
	-queryblocksize 8192
	-validate	0
	-headers	{}
	-timeout	0
	-type		application/x-www-form-urlencoded
	-queryprogress	{}
	-protocol	1.1
	binary		0
	state		connecting
	meta		{}
	coding		{}
	currentsize	0
	totalsize	0
	querylength	0
	queryoffset	0
	type		text/html
	body		{}
	status		""
	http		""
	connection	close
    }
    set state(-keepalive) $defaultKeepalive
    set state(-strict) $strict
    # These flags have their types verified [Bug 811170]
    array set type {
	-binary		boolean
	-blocksize	integer
	-queryblocksize integer
	-strict		boolean
	-timeout	integer
	-validate	boolean
    }
    set state(charset)	$defaultCharset
    set options {
	-binary -blocksize -channel -command -handler -headers -keepalive
	-method -myaddr -progress -protocol -query -queryblocksize
	-querychannel -queryprogress -strict -timeout -type -validate
    }
    set usage [join [lsort $options] ", "]
    set options [string map {- ""} $options]
    set pat ^-([join $options |])$
    foreach {flag value} $args {
	if {[regexp -- $pat $flag]} {
	    # Validate numbers
	    if {[info exists type($flag)] &&
		![string is $type($flag) -strict $value]} {
		unset $token
		return -code error "Bad value for $flag ($value), must be $type($flag)"
	    }
	    set state($flag) $value
	} else {
	    unset $token
	    return -code error "Unknown option $flag, can be: $usage"
	}
    }

    # Make sure -query and -querychannel aren't both specified

    set isQueryChannel [info exists state(-querychannel)]
    set isQuery [info exists state(-query)]
    if {$isQuery && $isQueryChannel} {
	unset $token
	return -code error "Can't combine -query and -querychannel options!"
    }

    # Validate URL, determine the server host and port, and check proxy case
    # Recognize user:pass@host URLs also, although we do not do anything with
    # that info yet.

    # URLs have basically four parts.
    # First, before the colon, is the protocol scheme (e.g. http)
    # Second, for HTTP-like protocols, is the authority
    #	The authority is preceded by // and lasts up to (but not including)
    #	the following / and it identifies up to four parts, of which only one,
    #	the host, is required (if an authority is present at all). All other
    #	parts of the authority (user name, password, port number) are optional.
    # Third is the resource name, which is split into two parts at a ?
    #	The first part (from the single "/" up to "?") is the path, and the
    #	second part (from that "?" up to "#") is the query. *HOWEVER*, we do
    #	not need to separate them; we send the whole lot to the server.
    # Fourth is the fragment identifier, which is everything after the first
    #	"#" in the URL. The fragment identifier MUST NOT be sent to the server
    #	and indeed, we don't bother to validate it (it could be an error to
    #	pass it in here, but it's cheap to strip).
    #
    # An example of a URL that has all the parts:
    #   http://jschmoe:xyzzy@www.bogus.net:8000/foo/bar.tml?q=foo#changes
    # The "http" is the protocol, the user is "jschmoe", the password is
    # "xyzzy", the host is "www.bogus.net", the port is "8000", the path is
    # "/foo/bar.tml", the query is "q=foo", and the fragment is "changes".
    #
    # Note that the RE actually combines the user and password parts, as
    # recommended in RFC 3986. Indeed, that RFC states that putting passwords
    # in URLs is a Really Bad Idea, something with which I would agree utterly.
    # Also note that we do not currently support IPv6 addresses.
    #
    # From a validation perspective, we need to ensure that the parts of the
    # URL that are going to the server are correctly encoded.
    # This is only done if $state(-strict) is true (inherited from
    # $::http::strict).

    set URLmatcher {(?x)		# this is _expanded_ syntax
	^
	(?: (\w+) : ) ?			# <protocol scheme>
	(?: //
	    (?:
		(
		    [^@/\#?]+		# <userinfo part of authority>
		) @
	    )?
	    ( [^/:\#?]+ )		# <host part of authority>
	    (?: : (\d+) )?		# <port part of authority>
	)?
	( / [^\#?]* (?: \? [^\#?]* )?)?	# <path> (including query)
	(?: \# (.*) )?			# <fragment>
	$
    }

    # Phase one: parse
    if {![regexp -- $URLmatcher $url -> proto user host port srvurl]} {
	unset $token
	return -code error "Unsupported URL: $url"
    }
    # Phase two: validate
    if {$host eq ""} {
	# Caller has to provide a host name; we do not have a "default host"
	# that would enable us to handle relative URLs.
	unset $token
	return -code error "Missing host part: $url"
	# Note that we don't check the hostname for validity here; if it's
	# invalid, we'll simply fail to resolve it later on.
    }
    if {$port ne "" && $port > 65535} {
	unset $token
	return -code error "Invalid port number: $port"
    }
    # The user identification and resource identification parts of the URL can
    # have encoded characters in them; take care!
    if {$user ne ""} {
	# Check for validity according to RFC 3986, Appendix A
	set validityRE {(?xi)
	    ^
	    (?: [-\w.~!$&'()*+,;=:] | %[0-9a-f][0-9a-f] )+
	    $
	}
	if {$state(-strict) && ![regexp -- $validityRE $user]} {
	    unset $token
	    # Provide a better error message in this error case
	    if {[regexp {(?i)%(?![0-9a-f][0-9a-f]).?.?} $user bad]} {
		return -code error "Illegal encoding character usage \"$bad\" in URL user"
	    }
	    return -code error "Illegal characters in URL user"
	}
    }
    if {$srvurl ne ""} {
	# Check for validity according to RFC 3986, Appendix A
	set validityRE {(?xi)
	    ^
	    # Path part (already must start with / character)
	    (?:	      [-\w.~!$&'()*+,;=:@/]  | %[0-9a-f][0-9a-f] )*
	    # Query part (optional, permits ? characters)
	    (?: \? (?: [-\w.~!$&'()*+,;=:@/?] | %[0-9a-f][0-9a-f] )* )?
	    $
	}
	if {$state(-strict) && ![regexp -- $validityRE $srvurl]} {
	    unset $token
	    # Provide a better error message in this error case
	    if {[regexp {(?i)%(?![0-9a-f][0-9a-f])..} $srvurl bad]} {
		return -code error "Illegal encoding character usage \"$bad\" in URL path"
	    }
	    return -code error "Illegal characters in URL path"
	}
    } else {
	set srvurl /
    }
    if {$proto eq ""} {
	set proto http
    }
    if {![info exists urlTypes($proto)]} {
	unset $token
	return -code error "Unsupported URL type \"$proto\""
    }
    set defport [lindex $urlTypes($proto) 0]
    set defcmd [lindex $urlTypes($proto) 1]

    if {$port eq ""} {
	set port $defport
    }
    if {![catch {$http(-proxyfilter) $host} proxy]} {
	set phost [lindex $proxy 0]
	set pport [lindex $proxy 1]
    }

    # OK, now reassemble into a full URL
    set url ${proto}://
    if {$user ne ""} {
	append url $user
	append url @
    }
    append url $host
    if {$port != $defport} {
	append url : $port
    }
    append url $srvurl
    # Don't append the fragment!
    set state(url) $url

    # If a timeout is specified we set up the after event and arrange for an
    # asynchronous socket connection.

    set sockopts [list]
    if {$state(-timeout) > 0} {
	set state(after) [after $state(-timeout) [list http::reset $token timeout]]
	lappend sockopts -async
    }

    # If we are using the proxy, we must pass in the full URL that includes
    # the server name.

    if {[info exists phost] && ($phost ne "")} {
	set srvurl $url
	set targetAddr [list $phost $pport]
    } else {
	set targetAddr [list $host $port]
    }
    # Proxy connections aren't shared among different hosts.
    set state(socketinfo) $host:$port

    # See if we are supposed to use a previously opened channel.
    if {$state(-keepalive)} {
	variable socketmap
	if {[info exists socketmap($state(socketinfo))]} {
	    if {[catch {fconfigure $socketmap($state(socketinfo))}]} {
		Log "WARNING: socket for $state(socketinfo) was closed"
		unset socketmap($state(socketinfo))
	    } else {
		set sock $socketmap($state(socketinfo))
		Log "reusing socket $sock for $state(socketinfo)"
		catch {fileevent $sock writable {}}
		catch {fileevent $sock readable {}}
	    }
	}
	# don't automatically close this connection socket
	set state(connection) {}
    }
    if {![info exists sock]} {
	# Pass -myaddr directly to the socket command
	if {[info exists state(-myaddr)]} {
	    lappend sockopts -myaddr $state(-myaddr)
	}
        if {[catch {eval $defcmd $sockopts $targetAddr} sock]} {
            # something went wrong while trying to establish the
            # connection. Clean up after events and such, but DON'T call the
            # command callback (if available) because we're going to throw an
            # exception from here instead.

	    set state(sock) $sock
            Finish $token "" 1
            cleanup $token
            return -code error $sock
        }
    }
    set state(sock) $sock
    Log "Using $sock for $state(socketinfo)" [expr {$state(-keepalive)?"keepalive":""}]
    if {$state(-keepalive)} {
        set socketmap($state(socketinfo)) $sock
    }

    # Wait for the connection to complete.

    if {$state(-timeout) > 0} {
	fileevent $sock writable [list http::Connect $token]
	http::wait $token

	if {![info exists state]} {
	    # If we timed out then Finish has been called and the users
	    # command callback may have cleaned up the token. If so
	    # we end up here with nothing left to do.
	    return $token
	} elseif {$state(status) eq "error"} {
	    # Something went wrong while trying to establish the connection.
	    # Clean up after events and such, but DON'T call the command
	    # callback (if available) because we're going to throw an
	    # exception from here instead.
	    set err [lindex $state(error) 0]
	    cleanup $token
	    return -code error $err
	} elseif {$state(status) ne "connect"} {
	    # Likely to be connection timeout
	    return $token
	}
	set state(status) ""
    }

    # Send data in cr-lf format, but accept any line terminators

    fconfigure $sock -translation {auto crlf} -buffersize $state(-blocksize)

    # The following is disallowed in safe interpreters, but the socket is
    # already in non-blocking mode in that case.

    catch {fconfigure $sock -blocking off}
    set how GET
    if {$isQuery} {
	set state(querylength) [string length $state(-query)]
	if {$state(querylength) > 0} {
	    set how POST
	    set contDone 0
	} else {
	    # There's no query data.
	    unset state(-query)
	    set isQuery 0
	}
    } elseif {$state(-validate)} {
	set how HEAD
    } elseif {$isQueryChannel} {
	set how POST
	# The query channel must be blocking for the async Write to
	# work properly.
	fconfigure $state(-querychannel) -blocking 1 -translation binary
	set contDone 0
    }
    if {[info exists state(-method)] && $state(-method) ne ""} {
	set how $state(-method)
    }

    if {[catch {
	puts $sock "$how $srvurl HTTP/$state(-protocol)"
	puts $sock "Accept: $http(-accept)"
	array set hdrs $state(-headers)
	if {[info exists hdrs(Host)]} {
	    # Allow Host spoofing [Bug 928154]
	    puts $sock "Host: $hdrs(Host)"
	} elseif {$port == $defport} {
	    # Don't add port in this case, to handle broken servers.
	    # [Bug #504508]
	    puts $sock "Host: $host"
	} else {
	    puts $sock "Host: $host:$port"
	}
	unset hdrs
	puts $sock "User-Agent: $http(-useragent)"
        if {$state(-protocol) == 1.0 && $state(-keepalive)} {
            puts $sock "Connection: keep-alive"
        }
        if {$state(-protocol) > 1.0 && !$state(-keepalive)} {
            puts $sock "Connection: close" ;# RFC2616 sec 8.1.2.1
        }
        if {[info exists phost] && ($phost ne "") && $state(-keepalive)} {
            puts $sock "Proxy-Connection: Keep-Alive"
        }
        set accept_encoding_seen 0
	foreach {key value} $state(-headers) {
	    if {[string equal -nocase $key "host"]} { continue }
            if {[string equal -nocase $key "accept-encoding"]} {
                set accept_encoding_seen 1
            }
	    set value [string map [list \n "" \r ""] $value]
	    set key [string trim $key]
	    if {[string equal -nocase $key "content-length"]} {
		set contDone 1
		set state(querylength) $value
	    }
	    if {[string length $key]} {
		puts $sock "$key: $value"
	    }
	}
	# Soft zlib dependency check - no package require
        if {!$accept_encoding_seen && [llength [package provide zlib]]
            && !([info exists state(-channel)] || [info exists state(-handler)])
        } {
            puts $sock "Accept-Encoding: gzip, identity, *;q=0.1"
        }
	if {$isQueryChannel && $state(querylength) == 0} {
	    # Try to determine size of data in channel. If we cannot seek, the
	    # surrounding catch will trap us

	    set start [tell $state(-querychannel)]
	    seek $state(-querychannel) 0 end
	    set state(querylength) [expr {[tell $state(-querychannel)] - $start}]
	    seek $state(-querychannel) $start
	}

	# Flush the request header and set up the fileevent that will either
	# push the POST data or read the response.
	#
	# fileevent note:
	#
	# It is possible to have both the read and write fileevents active at
	# this point. The only scenario it seems to affect is a server that
	# closes the connection without reading the POST data. (e.g., early
	# versions TclHttpd in various error cases). Depending on the platform,
	# the client may or may not be able to get the response from the server
	# because of the error it will get trying to write the post data.
	# Having both fileevents active changes the timing and the behavior,
	# but no two platforms (among Solaris, Linux, and NT) behave the same,
	# and none behave all that well in any case. Servers should always read
	# their POST data if they expect the client to read their response.

	if {$isQuery || $isQueryChannel} {
	    puts $sock "Content-Type: $state(-type)"
	    if {!$contDone} {
		puts $sock "Content-Length: $state(querylength)"
	    }
	    puts $sock ""
	    fconfigure $sock -translation {auto binary}
	    fileevent $sock writable [list http::Write $token]
	} else {
	    puts $sock ""
	    flush $sock
	    fileevent $sock readable [list http::Event $sock $token]
	}

	if {! [info exists state(-command)]} {
	    # geturl does EVERYTHING asynchronously, so if the user calls it
	    # synchronously, we just do a wait here.

	    wait $token
	    if {$state(status) eq "error"} {
		# Something went wrong, so throw the exception, and the
		# enclosing catch will do cleanup.
		return -code error [lindex $state(error) 0]
	    }
	}
    } err]} {
	# The socket probably was never connected, or the connection dropped
	# later.

	# Clean up after events and such, but DON'T call the command callback
	# (if available) because we're going to throw an exception from here
	# instead.

	# if state(status) is error, it means someone's already called Finish
	# to do the above-described clean up.
	if {$state(status) ne "error"} {
	    Finish $token $err 1
	}
	cleanup $token
	return -code error $err
    }

    return $token
}

# Data access functions:
# Data - the URL data
# Status - the transaction status: ok, reset, eof, timeout
# Code - the HTTP transaction code, e.g., 200
# Size - the size of the URL data

proc http::data {token} {
    variable $token
    upvar 0 $token state
    return $state(body)
}
proc http::status {token} {
    if {![info exists $token]} { return "error" }
    variable $token
    upvar 0 $token state
    return $state(status)
}
proc http::code {token} {
    variable $token
    upvar 0 $token state
    return $state(http)
}
proc http::ncode {token} {
    variable $token
    upvar 0 $token state
    if {[regexp {[0-9]{3}} $state(http) numeric_code]} {
	return $numeric_code
    } else {
	return $state(http)
    }
}
proc http::size {token} {
    variable $token
    upvar 0 $token state
    return $state(currentsize)
}
proc http::meta {token} {
    variable $token
    upvar 0 $token state
    return $state(meta)
}
proc http::error {token} {
    variable $token
    upvar 0 $token state
    if {[info exists state(error)]} {
	return $state(error)
    }
    return ""
}

# http::cleanup
#
#	Garbage collect the state associated with a transaction
#
# Arguments
#	token	The token returned from http::geturl
#
# Side Effects
#	unsets the state array

proc http::cleanup {token} {
    variable $token
    upvar 0 $token state
    if {[info exists state]} {
	unset state
    }
}

# http::Connect
#
#	This callback is made when an asyncronous connection completes.
#
# Arguments
#	token	The token returned from http::geturl
#
# Side Effects
#	Sets the status of the connection, which unblocks
# 	the waiting geturl call

proc http::Connect {token} {
    variable $token
    upvar 0 $token state
    global errorInfo errorCode
    if {[eof $state(sock)] ||
	[string length [fconfigure $state(sock) -error]]} {
	    Finish $token "connect failed [fconfigure $state(sock) -error]" 1
    } else {
	set state(status) connect
	fileevent $state(sock) writable {}
    }
    return
}

# http::Write
#
#	Write POST query data to the socket
#
# Arguments
#	token	The token for the connection
#
# Side Effects
#	Write the socket and handle callbacks.

proc http::Write {token} {
    variable $token
    upvar 0 $token state
    set sock $state(sock)

    # Output a block.  Tcl will buffer this if the socket blocks
    set done 0
    if {[catch {
	# Catch I/O errors on dead sockets

	if {[info exists state(-query)]} {
	    # Chop up large query strings so queryprogress callback can give
	    # smooth feedback.

	    puts -nonewline $sock [string range $state(-query) $state(queryoffset) [expr {$state(queryoffset) + $state(-queryblocksize) - 1}]]
	    incr state(queryoffset) $state(-queryblocksize)
	    if {$state(queryoffset) >= $state(querylength)} {
		set state(queryoffset) $state(querylength)
		puts $sock ""
		set done 1
	    }
	} else {
	    # Copy blocks from the query channel

	    set outStr [read $state(-querychannel) $state(-queryblocksize)]
	    puts -nonewline $sock $outStr
	    incr state(queryoffset) [string length $outStr]
	    if {[eof $state(-querychannel)]} {
		set done 1
	    }
	}
    } err]} {
	# Do not call Finish here, but instead let the read half of the socket
	# process whatever server reply there is to get.

	set state(posterror) $err
	set done 1
    }
    if {$done} {
	catch {flush $sock}
	fileevent $sock writable {}
	fileevent $sock readable [list http::Event $sock $token]
    }

    # Callback to the client after we've completely handled everything.

    if {[string length $state(-queryprogress)]} {
	eval $state(-queryprogress) [list $token $state(querylength) $state(queryoffset)]
    }
}

# http::Event
#
#	Handle input on the socket
#
# Arguments
#	sock	The socket receiving input.
#	token	The token returned from http::geturl
#
# Side Effects
#	Read the socket and handle callbacks.

proc http::Event {sock token} {
    variable $token
    upvar 0 $token state

    if {![info exists state]} {
	Log "Event $sock with invalid token '$token' - remote close?"
	if {! [eof $sock]} {
	    if {[string length [set d [read $sock]]] != 0} {
		Log "WARNING: additional data left on closed socket"
	    }
	}
	CloseSocket $sock
	return
    }
    if {$state(state) eq "connecting"} {
	set state(state) "header"
	if {[catch {gets $sock state(http)} n]} {
	    return [Finish $token $n]
	}
    } elseif {$state(state) eq "header"} {
	if {[catch {gets $sock line} n]} {
	    return [Finish $token $n]
	} elseif {$n == 0} {
	    # We have now read all headers
	    # We ignore HTTP/1.1 100 Continue returns. RFC2616 sec 8.2.3
	    if {$state(http) == "" || [lindex $state(http) 1] == 100} { return }

	    set state(state) body

	    # If doing a HEAD, then we won't get any body
	    if {$state(-validate)} {
		Eof $token
		return
	    }

	    # For non-chunked transfer we may have no body -- in this case we
	    # may get no further file event if the connection doesn't close and
	    # no more data is sent. We can tell and must finish up now - not
	    # later.
	    if {!(([info exists state(connection)]
		   && ($state(connection) eq "close"))
		  || [info exists state(transfer)])
		&&  $state(totalsize) == 0
	    } then {
		Log "body size is 0 and no events likely - complete."
		Eof $token
		return
	    }

	    # We have to use binary translation to count bytes properly.
	    fconfigure $sock -translation binary

	    if {$state(-binary) || ![string match -nocase text* $state(type)]} {
		# Turn off conversions for non-text data
		set state(binary) 1
	    }
	    if {$state(binary) || [string match *gzip* $state(coding)]
		|| [string match *compress* $state(coding)]} {
		if {[info exists state(-channel)]} {
		    fconfigure $state(-channel) -translation binary
		}
	    }
	    if {[info exists state(-channel)] && 
		![info exists state(-handler)]} {
		# Initiate a sequence of background fcopies
		fileevent $sock readable {}
		CopyStart $sock $token
		return
	    }
	} elseif {$n > 0} {
	    # Process header lines
	    if {[regexp -nocase {^([^:]+):(.+)$} $line x key value]} {
		switch -- [string tolower $key] {
		    content-type {
			set state(type) [string trim [string tolower $value]]
			# grab the optional charset information
			regexp -nocase {charset\s*=\s*(\S+?);?} $state(type) -> state(charset)
		    }
		    content-length {
			set state(totalsize) [string trim $value]
		    }
		    content-encoding {
			set state(coding) [string trim $value]
		    }
		    transfer-encoding {
			set state(transfer) [string trim [string tolower $value]]
		    }
		    proxy-connection -
		    connection {
			set state(connection) [string trim [string tolower $value]]
		    }
		}
		lappend state(meta) $key [string trim $value]
	    }
	}
    } else {
	# Now reading body
	if {[catch {
	    if {[info exists state(-handler)]} {
		set n [eval $state(-handler) [list $sock $token]]
	    } elseif {[info exists state(transfer_final)]} {
		set line [getTextLine $sock]
		set n [string length $line]
		if {$n > 0} {
		    Log "found $n bytes following final chunk"
		    append state(transfer_final) $line
		} else {
		    Log "final chunk part"
		    Eof $token
		}
	    } elseif {[info exists state(transfer)]
		      && $state(transfer) eq "chunked"} {
		set size 0
		set chunk [getTextLine $sock]
		set n [string length $chunk]
		if {[string trim $chunk] ne ""} {
		    scan $chunk %x size
		    if {$size != 0} {
			set bl [fconfigure $sock -blocking]
			fconfigure $sock -blocking 1
			set chunk [read $sock $size]
			fconfigure $sock -blocking $bl
			set n [string length $chunk]
			if {$n >= 0} {
			    append state(body) $chunk
			}
			if {$size != [string length $chunk]} {
			    Log "WARNING: mis-sized chunk: was [string length $chunk], should be $size"
			}
			getTextLine $sock
		    } else {
			set state(transfer_final) {}
		    }
		}
	    } else {
		#Log "read non-chunk $state(currentsize) of $state(totalsize)"
		set block [read $sock $state(-blocksize)]
		set n [string length $block]
		if {$n >= 0} {
		    append state(body) $block
		}
	    }
	    if {[info exists state]} {
		if {$n >= 0} {
		    incr state(currentsize) $n
		}
		# If Content-Length - check for end of data.
		if {($state(totalsize) > 0)
		    && ($state(currentsize) >= $state(totalsize))} {
		    Eof $token
		}
	    }
	} err]} {
	    return [Finish $token $err]
	} else {
	    if {[info exists state(-progress)]} {
		eval $state(-progress) [list $token $state(totalsize) $state(currentsize)]
	    }
	}
    }

    # catch as an Eof above may have closed the socket already
    if {![catch {eof $sock} eof] && $eof} {
	if {[info exists $token]} {
	    set state(connection) close
	    Eof $token
	} else {
	    # open connection closed on a token that has been cleaned up.
	    CloseSocket $sock
	}
	return
    }
}

# http::getTextLine --
#
#	Get one line with the stream in blocking crlf mode
#
# Arguments
#	sock	The socket receiving input.
#
# Results:
#	The line of text, without trailing newline

proc http::getTextLine {sock} {
    set tr [fconfigure $sock -translation]
    set bl [fconfigure $sock -blocking]
    fconfigure $sock -translation crlf -blocking 1
    set r [gets $sock]
    fconfigure $sock -translation $tr -blocking $bl
    return $r
}

# http::CopyStart
#
#	Error handling wrapper around fcopy
#
# Arguments
#	sock	The socket to copy from
#	token	The token returned from http::geturl
#
# Side Effects
#	This closes the connection upon error

proc http::CopyStart {sock token} {
    variable $token
    upvar 0 $token state
    if {[catch {
	fcopy $sock $state(-channel) -size $state(-blocksize) -command [list http::CopyDone $token]
    } err]} {
	Finish $token $err
    }
}

# http::CopyDone
#
#	fcopy completion callback
#
# Arguments
#	token	The token returned from http::geturl
#	count	The amount transfered
#
# Side Effects
#	Invokes callbacks

proc http::CopyDone {token count {error {}}} {
    variable $token
    upvar 0 $token state
    set sock $state(sock)
    incr state(currentsize) $count
    if {[info exists state(-progress)]} {
	eval $state(-progress) [list $token $state(totalsize) $state(currentsize)]
    }
    # At this point the token may have been reset
    if {[string length $error]} {
	Finish $token $error
    } elseif {[catch {eof $sock} iseof] || $iseof} {
	Eof $token
    } else {
	CopyStart $sock $token
    }
}

# http::Eof
#
#	Handle eof on the socket
#
# Arguments
#	token	The token returned from http::geturl
#
# Side Effects
#	Clean up the socket

proc http::Eof {token {force 0}} {
    variable $token
    upvar 0 $token state
    if {$state(state) eq "header"} {
	# Premature eof
	set state(status) eof
    } else {
	set state(status) ok
    }

    if {($state(coding) eq "gzip") && [string length $state(body)] > 0} {
        if {[catch {
            set state(body) [Gunzip $state(body)]
        } err]} {
            return [Finish $token $err]
        }
    }

    if {!$state(binary)} {

        # If we are getting text, set the incoming channel's
        # encoding correctly.  iso8859-1 is the RFC default, but
        # this could be any IANA charset.  However, we only know
        # how to convert what we have encodings for.

        set enc [CharsetToEncoding $state(charset)]
        if {$enc ne "binary"} {
            set state(body) [encoding convertfrom $enc $state(body)]
        }

        # Translate text line endings.
        set state(body) [string map {\r\n \n \r \n} $state(body)]
    }

    Finish $token
}

# http::wait --
#
#	See documentation for details.
#
# Arguments:
#	token	Connection token.
#
# Results:
#        The status after the wait.

proc http::wait {token} {
    variable $token
    upvar 0 $token state

    if {![info exists state(status)] || $state(status) eq ""} {
	# We must wait on the original variable name, not the upvar alias
	vwait ${token}(status)
    }

    return [status $token]
}

# http::formatQuery --
#
#	See documentation for details.  Call http::formatQuery with an even
#	number of arguments, where the first is a name, the second is a value,
#	the third is another name, and so on.
#
# Arguments:
#	args	A list of name-value pairs.
#
# Results:
#	TODO

proc http::formatQuery {args} {
    set result ""
    set sep ""
    foreach i $args {
	append result $sep [mapReply $i]
	if {$sep eq "="} {
	    set sep &
	} else {
	    set sep =
	}
    }
    return $result
}

# http::mapReply --
#
#	Do x-www-urlencoded character mapping
#
# Arguments:
#	string	The string the needs to be encoded
#
# Results:
#       The encoded string

proc http::mapReply {string} {
    variable http
    variable formMap

    # The spec says: "non-alphanumeric characters are replaced by '%HH'". Use
    # a pre-computed map and [string map] to do the conversion (much faster
    # than [regsub]/[subst]). [Bug 1020491]

    if {$http(-urlencoding) ne ""} {
	set string [encoding convertto $http(-urlencoding) $string]
	return [string map $formMap $string]
    }
    set converted [string map $formMap $string]
    if {[string match "*\[\u0100-\uffff\]*" $converted]} {
	regexp {[\u0100-\uffff]} $converted badChar
	# Return this error message for maximum compatability... :^/
	return -code error "can't read \"formMap($badChar)\": no such element in array"
    }
    return $converted
}

# http::ProxyRequired --
#	Default proxy filter.
#
# Arguments:
#	host	The destination host
#
# Results:
#       The current proxy settings

proc http::ProxyRequired {host} {
    variable http
    if {[info exists http(-proxyhost)] && [string length $http(-proxyhost)]} {
	if {![info exists http(-proxyport)] || ![string length $http(-proxyport)]} {
	    set http(-proxyport) 8080
	}
	return [list $http(-proxyhost) $http(-proxyport)]
    }
}

# http::CharsetToEncoding --
#
# 	Tries to map a given IANA charset to a tcl encoding.
#	If no encoding can be found, returns binary.
#

proc http::CharsetToEncoding {charset} {
    variable encodings

    set charset [string tolower $charset]
    if {[regexp {iso-?8859-([0-9]+)} $charset - num]} {
	set encoding "iso8859-$num"
    } elseif {[regexp {iso-?2022-(jp|kr)} $charset - ext]} {
	set encoding "iso2022-$ext"
    } elseif {[regexp {shift[-_]?js} $charset -]} {
	set encoding "shiftjis"
    } elseif {[regexp {(windows|cp)-?([0-9]+)} $charset - - num]} {
	set encoding "cp$num"
    } elseif {$charset eq "us-ascii"} {
	set encoding "ascii"
    } elseif {[regexp {(iso-?)?lat(in)?-?([0-9]+)} $charset - - - num]} {
	switch -- $num {
	    5 {set encoding "iso8859-9"}
	    1 -
	    2 -
	    3 {set encoding "iso8859-$num"}
	}
    } else {
	# other charset, like euc-xx, utf-8,...  may directly maps to encoding
	set encoding $charset
    }
    set idx [lsearch -exact $encodings $encoding]
    if {$idx >= 0} {
	return $encoding
    } else {
	return "binary"
    }
}

# http::Gunzip --
#
#	Decompress data transmitted using the gzip transfer coding.
#

# FIX ME: redo using zlib sinflate
proc http::Gunzip {data} {
    binary scan $data Scb5icc magic method flags time xfl os
    set pos 10
    if {$magic != 0x1f8b} {
        return -code error "invalid data: supplied data is not in gzip format"
    }
    if {$method != 8} {
        return -code error "invalid compression method"
    }

    foreach {f_text f_crc f_extra f_name f_comment} [split $flags ""] break
    set extra ""
    if { $f_extra } {
	binary scan $data @${pos}S xlen
        incr pos 2
        set extra [string range $data $pos $xlen]
        set pos [incr xlen]
    }

    set name ""
    if { $f_name } {
        set ndx [string first \0 $data $pos]
        set name [string range $data $pos $ndx]
        set pos [incr ndx]
    }

    set comment ""
    if { $f_comment } {
        set ndx [string first \0 $data $pos]
        set comment [string range $data $pos $ndx]
        set pos [incr ndx]
    }

    set fcrc ""
    if { $f_crc } {
	set fcrc [string range $data $pos [incr pos]]
        incr pos
    }

    binary scan [string range $data end-7 end] ii crc size
    set inflated [zlib inflate [string range $data $pos end-8]]
    set chk [zlib crc32 $inflated]
    if { ($crc & 0xffffffff) != ($chk & 0xffffffff)} {
	return -code error "invalid data: checksum mismatch $crc != $chk"
    }
    return $inflated
}

# Local variables:
# indent-tabs-mode: t
# End:

##package require http



     # Substitute for % "variables" (like %W, etc. in event bindings)
     # Based on [percent_subst] from Effective Tcl/Tk Programming by Mark
     # Harrison and Michael McLennan
     # Example:
     #   tclsh>perSub "%1 %2 %3" %1 one %3 three %2 two
     #   one two three
     package require opt
     ::tcl::OptProc perSub {
         {string  -string "" "String to work on"}
         {pattern -string "" "What to substitute for, e.g., %v"}
         {subst   -string "" "What to put in for $pattern"}
         {args    -list   {} "More pattern/subst pairs"}
     } {
         # Add the required instances to the optional list
         set args [linsert $args 0 $pattern $subst]
         # Process the list
         foreach {pattern subst} $args {
             # Validate pattern
             if { ! [string match %* $pattern]} {
                 error "Bad pattern <<$pattern>>: Should be %something"
             }
             # Escape dangerous characters ('\' and '&') in
             # substitution string
             regsub -all {\\|&} $subst {\\\0} subst
             # Do substitutions on string
             regsub -all $pattern $string $subst string
         }
         return $string
     }


  proc showHtml { htmlFile } {
   global qappCmd
      # Look for the application under
      # HKEY_CLASSES_ROOT
      set root HKEY_CLASSES_ROOT

      # Get the application key for HTML files
      set appKey [registry get $root\\.html ""]

      # Get the command for opening HTML files
      set appCmd [registry get $root\\$appKey\\shell\\open\\command ""]

#puts "appCmd=$appCmd"

set qappCmd ""
set delim "/"
foreach hhh [split $appCmd "\\/\""] {
 if { "$hhh" != "" } {
 if { "$delim" != "" } {
  set ourlen [string length $hhh]
  set sufft "~1"
  set ourfive 5
  if { [ourstringfirst $hhh ".EXE" 0] >= 0 } {
    set delim ""
    set ourlen [expr {[ourstringfirst $hhh ".EXE" 0] + 3}]
    set ourfive $ourlen
    set sufft ""
  }
  if { [ourstringfirst $hhh ".exe" 0] >= 0 } {
    set delim ""
    set ourlen [expr {[ourstringfirst $hhh ".exe" 0] + 3}]
    set ourfive $ourlen
    set sufft ""
  }
  if { [string length $hhh] > 8 } {
    set qappCmd "$qappCmd[string range $hhh 0 $ourfive]$sufft$delim"
  } else {
    set qappCmd "$qappCmd[string range $hhh 0 $ourlen]$delim"
  }
 }
 }
}

      ## Substitute the HTML filename into the
      ## command for %1
      #set appCmd [perSub $appCmd %1 $htmlFile]
##puts "qappCmd=$qappCmd appCmd2=$appCmd"

      ## Double up the backslashes for eval (below)
      #regsub -all {\\} $appCmd  {\\\\} appCmd

      ## Invoke the command
      ##puts "appCmd=$appCmd"
      ##eval exec $appCmd &
  }

    proc _launchBrowser {xurl} {
      global tcl_platform
      global qappCmd

    # It *is* generally a mistake to switch on $tcl_platform(os), particularly
    # in comparison to $tcl_platform(platform).  For now, let's just regard it
    # as a stylistic variation subject to debate.
      switch $tcl_platform(os) {
	Darwin {
	  set command [list open $xurl]
	}
	HP-UX -
	Linux  -
	SunOS {
	  foreach executable {firefox mozilla netscape iexplorer opera lynx
		       w3m links epiphany galeon konqueror mosaic amaya
		       browsex elinks} {
	    set executable [auto_execok $executable]
	    if [string length $executable] {
    # Do you want to mess with -remote?  How about other browsers?
	      set command [list $executable $xurl &]
	      break
	    }
	  }
	}
	{Windows 95} -
	{Windows NT} {
	  #puts "incoming=$xurl"
	  set command "[auto_execok start] {} [list $xurl]"
	  #puts "outgoing=$command"
	  
	  showHtml $xurl
	  set command ""

	  if [catch {exec $qappCmd $xurl &} err] {
	   tk_messageBox -icon error -message "error '$err' with '$command'"
	  }
	  
	  ##exec $qappCmd $xurl &
	  
	  
	}
      }
      if [info exists command] {
	# Replace {*}$command by eval "$command" if you want < tcl 8.5 compatibility ([RA])
        # Added the '&' to launch the browser as background process. [Duoas]
        if { "$command" != "" } {
	if [catch {exec {*}$command &} err] {
	  tk_messageBox -icon error -message "error '$err' with '$command'"
	}
	}
      } else {
	tk_messageBox -icon error -message "Please tell CL that ($tcl_platform(os), $tcl_platform(platform)) is not yet ready for browsing."
      }
    }



proc ourstringfirst { thestring compstring startpos } {
  global osf
  set osf -1
  set qqww $startpos
  set found 0
  set offset [expr {[string length $compstring] - 1}]
  while { $found == 0 && $qqww < [string length $thestring] } {
    if { [string range $thestring $qqww $qqww] == [string range $compstring 0 0] } {
        set qqwwplus [expr {$qqww + $offset}]
        if { [string range $thestring $qqww $qqwwplus] == $compstring } {
            set osf $qqww
            set found 1
        }
    }
    set qqww [expr {$qqww + 1}]
  }
  return $osf
}



proc ourstringlast { thestring compstring startpos } {
  global osf
  set osf -1
  set qqww $startpos
  set found 0
  set offset [expr {[string length $compstring] - 1}]
  while { $qqww < [string length $thestring] } {
    if { [string range $thestring $qqww $qqww] == [string range $compstring 0 0] } {
        set qqwwplus [expr {$qqww + $offset}]
        if { [string range $thestring $qqww $qqwwplus] == $compstring } {
            set osf $qqww
            set found 1
        }
    }
    set qqww [expr {$qqww + 1}]
  }
  return $osf
}

set huhbstatus "disabled"
set npbstatus "disabled"
set url ""
set html ""
set googleurl "http://www.google.com.au"

set gone 0
set nogosuffix " "
set wipeout "y"

set sqsize 15



set mode [expr {$sqsize * $sqsize}]

set bigstr ""
for {set i 1} {$i <= $mode} {set i [expr $i+1]} {
set bigstr "$bigstr $i"
}

if { [expr {1+round(rand()*1)}] == 1 || 9 == 9 } {
  set daMode "D"
  set odaMode "A"
} else {
  set daMode "A"
  set odaMode "D"
}

set numplay 1
set pb ""
set phraseTry ""
set phraseBigTry ""


set numthings 30

#set prenono(" ") "0"
#set prenono('') '0'
#set prenono("+") "0"
#set prenono('%') '0'
set prenono("A") "Q X ;   U I"
set prenono("B") "Q X W P F G H J K L Z C V N M D Y S T B ; R"
set prenono("C") "Q X W P F G H J K L Z B V N M D Y T C ; R"
set prenono("D") "Q X W P F G H J K L Z B V N M C Y S T D ; R"
set prenono("e") "Q ; X J Z K Y"
set prenono("E") "Q   ; X I U O E"
set prenono("F") "Q X W P G H J K L Z B V N M C Y D S T F ; R"
set prenono("G") "Q X W P F H J K L Z B V N M C Y D S T G ; R"
set prenono("H") "Q X F G J L Z B V N M Y I E U R K   ; A"
set prenono("I") "Q Y ;   U X"
set prenono("J") "Q X W P F G H K L Z B V N M C Y S T J A I U O E D R"
set prenono("K") "Q X W P F G H J B L Z C V N M D Y T K ; R"
set prenono("L") "Q X W H J K L Z V N M D Y T ; R"
set prenono("M") "Q X W P F G H J K L Z C V N M D Y T B    ; R"
set prenono("N") "Q X W P F H J L Z C V N M D Y T B    ; R G"
set prenono("O") "Q A X  ; U E O"
set prenono("P") "Q X W P F G H J K L Z C V N M D Y T B   ; R"
set prenono("Q") "Q X W P F G H J K L Z C V N M D Y S T B R"
set prenono("R") "Q X P H J L Z V N M Y B S    ; R"
set prenono("S") "Q X W F G H J K L Z C V N M D Y S B T   ; P S R"
set prenono("T") "Q X W P F G H J K L Z C V N M D Y T B   ; R"
set prenono("U") "U X Y ;   I"
set prenono("V") "Q X W P F G H J K L Z C V N M D Y T B   ; R"
set prenono("W") "Q X W P F G H J L Z C V N M Y B R"
set prenono("X") "Q X W P F G H J K L Z C V N M D Y S T B R"
set prenono("Y") "Q X Y B       I ; U"
set prenono("Z") "Q X W P F G H J K L Z C V N M D Y S T B R"

set desperateword 0
set desperatecontents ""
set desperateclue ""
set desperatecount 0
set desperatereveal "n"
set desperaterating 0
set desperatebackup ""

set donealready "0"

set sorder(1) 15
set sorder(2) 15

set sorder(3) 7 
set sorder(4) 7 
set sorder(5) 9 

set sorder(6) 4
set sorder(7) 4
set sorder(8) 8
set sorder(9) 6
set sorder(10) 8
set sorder(11) 6
set sorder(12) 8
set sorder(13) 8
set sorder(14) 8
set sorder(15) 8
set sorder(16) 6
set sorder(17) 8
set sorder(18) 6
set sorder(19) 8
set sorder(20) 4
set sorder(21) 4
set sorder(22) 5
set sorder(23) 7
set sorder(24) 9
set sorder(25) 5
set sorder(26) 5
set sorder(27) 7
set sorder(28) 5
set sorder(29) 7
set sorder(30) 7
  
set maps(1) 7     
set maps(2) 9

set maps(3) 1  
set maps(4) 4   
set maps(5) 11   

set maps(6) [expr {3 + 13}]
set maps(7) 2
set maps([expr {8 + 9}]) 13
set maps([expr {9 + 9}]) 14
set maps(10) [expr {15 + 5}]
set maps(11) [expr {16 - 13}]
set maps(12) 17
set maps(13) 18
set maps(14) 6
set maps(15) 19
set maps(16) [expr {20 - 5}]
set maps([expr {17 - 9}]) [expr {21 + 8}]
set maps([expr {18 - 9}]) [expr {22 + 8}]
set maps(19) 23
set maps(20) 10
set maps(21) 8
set maps(22) 12
set maps(23) 24
set maps(24) 5
set maps(25) 25 
set maps(26) 26
set maps(27) 27
set maps(28) 28
set maps(29) [expr {29 - 8}]
set maps(30) [expr {30 - 8}]



set worder(1) "               "
set worder(2) "               "
set worder(3) "       "
set worder(4) "       "
set worder(5) "         "
set worder(6) "    "
set worder(7) "    "
set worder(8) "        "
set worder(9) "      "
set worder(10) "        "
set worder(11) "      "
set worder(12) "        "
set worder(13) "        "
set worder(14) "        "
set worder(15) "        "
set worder(16) "      "
set worder(17) "        "
set worder(18) "      "
set worder(19) "        "
set worder(20) "    "
set worder(21) "    "
set worder(22) "     "
set worder(23) "     "
set worder(24) "         "
set worder(25) "     "
set worder(26) "     "
set worder(27) "       "
set worder(28) "     "
set worder(29) "       "
set worder(30) "       "

set corder(1) ""
set corder(2) ""
set corder(3) ""
set corder(4) ""
set corder(5) ""
set corder(6) ""
set corder(7) ""
set corder(8) ""
set corder(9) ""
set corder(10) ""
set corder(11) ""
set corder(12) ""
set corder(13) ""
set corder(14) ""
set corder(15) ""
set corder(16) ""
set corder(17) ""
set corder(18) ""
set corder(19) ""
set corder(20) ""
set corder(21) ""
set corder(22) ""
set corder(23) ""
set corder(24) ""
set corder(25) ""
set corder(26) ""
set corder(27) ""
set corder(28) ""
set corder(29) ""
set corder(30) ""


set morder(1) "$odaMode"
set morder(2) "$odaMode"

set morder(3) "$odaMode"
set morder(4) "$odaMode"
set morder(5) "$odaMode"


set morder(6) "$daMode"
set morder(7) "$daMode"
set morder(8) "$daMode"
set morder(9) "$daMode"
set morder(10) "$daMode"
set morder(11) "$daMode"
set morder(12) "$daMode"
set morder(13) "$daMode"
set morder(14) "$daMode"
set morder(15) "$daMode"
set morder(16) "$daMode"
set morder(17) "$daMode"
set morder(18) "$daMode"
set morder(19) "$daMode"
set morder(20) "$daMode"
set morder(21) "$daMode"
set morder(22) "$daMode"
set morder(23) "$odaMode"
set morder(24) "$odaMode"
set morder(25) "$odaMode"
set morder(26) "$daMode"
set morder(27) "$odaMode"
set morder(28) "$odaMode"
set morder(29) "$odaMode"
set morder(30) "$odaMode"



set xorder(1) "9$odaMode"
set xorder(2) "29$odaMode"

set xorder(3) "10$odaMode" 
set xorder(4) "15$odaMode" 
set xorder(5) "23$odaMode" 

set xorder(6) "1$daMode"
set xorder(7) "2$daMode"
set xorder(8) "3$daMode"
set xorder(9) "4$daMode"
set xorder(10) "5$daMode"
set xorder(11) "6$daMode"
set xorder(12) "7$daMode"
set xorder(13) "8$daMode"
set xorder(14) "15$daMode"
set xorder(15) "16$daMode"
set xorder(16) "22$daMode"
set xorder(17) "17$daMode"
set xorder(18) "24$daMode"
set xorder(19) "19$daMode"
set xorder(20) "27$daMode"
set xorder(21) "28$daMode"
set xorder(22) "11$daMode"
set xorder(23) "12$odaMode"
set xorder(24) "13$odaMode"
set xorder(25) "14$odaMode"
set xorder(26) "20$daMode"
set xorder(27) "18$odaMode"
set xorder(28) "21$odaMode"
set xorder(29) "25$odaMode"
set xorder(30) "26$odaMode"


set maps(1) 22
set maps(2) 4
set maps(3) 24
set maps(4) 23
set maps(5) 3
set maps(6) 14
set maps(7) 8
set maps(8) 1
set maps(9) 2
set maps(10) 27

set maps(11) 5
set maps(12) 15
set maps(13) 7
set maps(14) 6 
set maps(15) 11
set maps(16) 12
set maps(17) 13
set maps(18) 16
set maps(19) 17
set maps(20) 18
set maps(21) 19
set maps(22) 20
set maps(23) 21
set maps(24) 9 
set maps(25) 10 
set maps(26) 30
set maps(27) 26
set maps(28) 28
set maps(29) 29
set maps(30) 25







set oorder(1) 16
set oorder(2) 196

set oorder(3) 46   
set oorder(4) 106  
set oorder(5) 142  


set oorder(6) 1
set oorder(7) 3
set oorder(8) 5
set oorder(9) 7
set oorder(10) 9
set oorder(11) 11
set oorder(12) 13
set oorder(13) 15
set oorder(14) 106
set oorder(15) 108
set oorder(16) 140
set oorder(17) 112
set oorder(18) 144
set oorder(19) 116
set oorder(20) 178
set oorder(21) 180
set oorder(22) 47
set oorder(23) 54
set oorder(24) 76
set oorder(25) 86
set oorder(26) 119
set oorder(27) 114
set oorder(28) 136
set oorder(29) 166
set oorder(30) 174
  
set ourorder "$xorder(1) $xorder(2) $xorder(3) $xorder(4) $xorder(5) $xorder(6) $xorder(7) $xorder(8) $xorder(9) $xorder(10) $xorder(11) $xorder(12) $xorder(13) $xorder(14) $xorder(15) $xorder(16) $xorder(17) $xorder(18) $xorder(19) $xorder(20) $xorder(21) $xorder(22) $xorder(23) $xorder(24) $xorder(25) $xorder(26) $xorder(27) $xorder(28) $xorder(29) $xorder(30)"
set oourorder "$oorder(1) $oorder(2) $oorder(3) $oorder(4) $oorder(5) $oorder(6) $oorder(7) $oorder(8) $oorder(9) $oorder(10) $oorder(11) $oorder(12) $oorder(13) $oorder(14) $oorder(15) $oorder(16) $oorder(17) $oorder(18) $oorder(19) $oorder(20) $oorder(21) $oorder(22) $oorder(23) $oorder(24) $oorder(25) $oorder(26) $oorder(27) $oorder(28) $oorder(29) $oorder(30)"
set sourorder "$sorder(1) $sorder(2) $sorder(3) $sorder(4) $sorder(5) $sorder(6) $sorder(7) $sorder(8) $sorder(9) $sorder(10) $sorder(11) $sorder(12) $sorder(13) $sorder(14) $sorder(15) $sorder(16) $sorder(17) $sorder(18) $sorder(19) $sorder(20) $sorder(21) $sorder(22) $sorder(23) $sorder(24) $sorder(25) $sorder(26) $sorder(27) $sorder(28) $sorder(29) $sorder(30)"

for  {set iikk 0} {$iikk < $numthings} {set iikk [expr $iikk+1]} {
         set worder([expr {$iikk + 1}]) "$worder([expr {$iikk + 1}]) "
}


for {set ii 0} {$ii < $mode} {set ii [expr $ii+1]} {
  set barr([expr {$ii + 1}]) 0
  set varr([expr {$ii + 1}]) " "
  set arr([expr {$ii + 1}]) " "
  set marr([expr {$ii + 1}]) ""
  set xarr([expr {$ii + 1}]) ""
  set yarr([expr {$ii + 1}]) ""
  set zarr([expr {$ii + 1}]) ""
  set valoks([expr {$ii + 1}]) ""
}

for {set ii 0} {$ii < $mode} {set ii [expr $ii+1]} {
  set jkl 0
  foreach xxhuh "$oourorder" {
    set jkl [expr {$jkl + 1}]
    if { $xxhuh == [expr {$ii + 1}] } {
      set iy 0
      if { $morder([expr {$jkl}]) == "D" } {
        for {set iii $oorder([expr {$jkl}])} {$iii < ([expr {$oorder([expr {$jkl}]) + $sorder([expr {$jkl}]) * $sqsize}])} {set iii [expr $iii+$sqsize]} {
         set iy [expr {$iy + 1}]
         set barr([expr {$iii}]) 1
         set xarr([expr {$iii}]) "$xarr([expr {$iii}]) $xorder([expr {$jkl}])"
         set marr([expr {$iii}]) "$marr([expr {$iii}]) $morder([expr {$jkl}])"
         set yarr([expr {$iii}]) "$yarr([expr {$iii}]) $iy"
         set zarr([expr {$iii}]) "$zarr([expr {$iii}]) [expr {$jkl}]"
         
  #       puts "square $iii has zarr($iii)=$zarr($iii)  yarr($iii)=$yarr($iii)"
        }
      } else {
        for {set iii $oorder([expr {$jkl}])} {$iii < ([expr {$oorder([expr {$jkl}]) + $sorder([expr {$jkl}])}])} {set iii [expr $iii+1]} {
         set iy [expr {$iy + 1}]
         set barr([expr {$iii}]) 1
         set xarr([expr {$iii}]) "$xarr([expr {$iii}]) $xorder([expr {$jkl}])"
         set marr([expr {$iii}]) "$marr([expr {$iii}]) $morder([expr {$jkl}])"
         set yarr([expr {$iii}]) "$yarr([expr {$iii}]) $iy"
         set zarr([expr {$iii}]) "$zarr([expr {$iii}]) [expr {$jkl}]"
         
 #        puts "Square $iii has zarr($iii)=$zarr($iii)  yarr($iii)=$yarr($iii)"
        }
      }
    }
  }
}


set aorder(1) "1 3 5 7 9 11 13 15"
set aorder(2) "211 213 215 217 219 221 223 225"

set aorder(3) "" 
set aorder(4) "" 
set aorder(5) "" 

set aorder(6) "47"
set aorder(7) "208"
set aorder(8) ""
set aorder(9) ""
set aorder(10) ""
set aorder(11) ""
set aorder(12) "119"
set aorder(13) ""
set aorder(14) ""
set aorder(15) ""
set aorder(16) ""
set aorder(17) ""
set aorder(18) ""
set aorder(19) ""
set aorder(20) ""
set aorder(21) ""
set aorder(22) "76 106 108"
set aorder(23) ""
set aorder(24) ""
set aorder(25) ""
set aorder(26) "118"
set aorder(27) ""
set aorder(28) ""
set aorder(29) ""
set aorder(30) ""


set valoks(1) "A B C D E F G H I J K L M N O P Q R S T U V W X Y Z"
set valoks(2) "A B C D E F G H I J K L M N O P Q R S T U V W X Y Z"

set valoks(3) "10$odaMode" 
set valoks(4) "15$odaMode" 
set valoks(5) "23$odaMode" 

set valoks(6) "E R L H T C"
set valoks(7) "I"
set valoks(8) "3$daMode"
set valoks(9) "4$daMode"
set valoks(10) "5$daMode"
set valoks(11) "6$daMode"
set valoks(12) "A B C D E F G H I J K L M N O P Q R S T U V W X Y Z"
set valoks(13) "8$daMode"
set valoks(14) "15$daMode"
set valoks(15) "16$daMode"
set valoks(16) "22$daMode"
set valoks(17) "17$daMode"
set valoks(18) "24$daMode"
set valoks(19) "19$daMode"
set valoks(20) "27$daMode"
set valoks(21) "28$daMode"
set valoks(22) "A B C D E F G H I J K L M N O P Q R S T U V W X Y Z"
set valoks(23) "12$daMode"
set valoks(24) "13$odaMode"
set valoks(25) "14$odaMode"
set valoks(26) "A B C D E F G H I J K L M N O P Q R S T U V W X Y Z"
set valoks(27) "18$odaMode"
set valoks(28) "21$odaMode"
set valoks(29) "25$odaMode"
set valoks(30) "26$odaMode"

set goodNonChar " "
set okpos 1

proc asterTwo {oneBit thisWord firstLetterFlexibility} {
  global sorder worder phraseTry phraseBigTry goodNonChar okpos xorder
  set huh "?"
  set huhhuh "**"
  set huhbig "%3F"
  set huhhuhbig "**"
  if { "$firstLetterFlexibility" == "0" } {
  set phraseTry "$oneBit"
  set phraseBigTry "$oneBit"
  } else {
  set phraseBigTry "$oneBit"
  set phraseTry "$huhbig"
  }
  set lastSpace 0
  set goodNonSpace 0
  set goodNonChar " "
  set okpos 1
  set xq 1
  for {set iijj $sorder($thisWord)} {$iijj >= 2} {set iijj [expr $iijj-1]} {
    if { [string range "$worder($thisWord)" [expr {$iijj - 1}] [expr {$iijj - 1}]] == " " } {
      if { "$lastSpace" == "0" || "$goodNonSpace" == "0" } {
      set lastSpace $iijj
      }
    } else {
      set goodNonSpace $iijj
      if { "$goodNonChar" == " " } {
        set goodNonChar [string range "$worder($thisWord)" [expr {$iijj - 1}] [expr {$iijj - 1}]]
        set okpos $iijj
      }
    }
  } 
  
      if { "$goodNonChar" == " " } {
        set goodNonChar $oneBit
      }
      
  set goforit 0
  if { "$lastSpace" != "0" && ("$goodNonSpace" != "0" || 65 == 65) } {
  # two below new idea
  set goodNonSpace [expr {0 - $goodNonSpace}]
  set xq 0
  for {set iijj [expr {2 - $firstLetterFlexibility * 0}]} {$iijj <= $sorder($thisWord)} {set iijj [expr $iijj+1]} {
    if { [string range $worder($thisWord) [expr {$iijj - 1}] [expr {$iijj - 1}]] == " " } {
      if { "$iijj" == "$lastSpace" } {
      set phraseTry "$phraseTry$huhhuh$huh"
      set phraseBigTry "$phraseBigTry$huhhuhbig$huhbig"
      } else {
      set phraseTry "$phraseTry$huh"
      set phraseBigTry "$phraseBigTry$huhbig"
      }
      set goforit $xq
    } else {
      if { "$iijj" == "$goodNonSpace" || "$goforit" == "1" } {
      set phraseTry "$phraseTry$huhhuh[string range $worder($thisWord) [expr {$iijj - 1}] [expr {$iijj - 1}]]"
      set phraseBigTry "$phraseBigTry$huhhuhbig[string range $worder($thisWord) [expr {$iijj - 1}] [expr {$iijj - 1}]]"
  set goforit 0
      } else {
      set phraseTry "$phraseTry[string range $worder($thisWord) [expr {$iijj - 1}] [expr {$iijj - 1}]]"
      set phraseBigTry "$phraseBigTry[string range $worder($thisWord) [expr {$iijj - 1}] [expr {$iijj - 1}]]"
      }
    }
  } 
  } else {
    set phraseTry ""
    set phraseBigTry ""
  }
  
  set phraseBigTry [eval {extraIntelligence $phraseBigTry $thisWord $sorder($thisWord) $xorder($thisWord)}]
  return "$phraseTry"
}


proc giveBackLetter {theWord thePos befVsAft} {
  global mode sqsize oorder morder varr
  set retVal "e"
  if { "$befVsAft" == "0" } {
    if { "$morder($theWord)" == "D" } {
      set ourSqu [expr {$oorder($theWord) + ($thePos - 1) * $sqsize}]
      set compSqu [expr {$ourSqu + 1}]
      if { "$compSqu" <= "$mode" } {
        if { "$varr($compSqu)" != "" && "$varr($compSqu)" != " " } {
          return "$varr($compSqu)"
        }
      }
    } else {
      set ourSqu [expr {$oorder($theWord) + ($thePos - 1) * 1}]
      set compSqu [expr {$ourSqu + $sqsize}]
      if { "$compSqu" <= "$mode" } {
        if { "$varr($compSqu)" != "" && "$varr($compSqu)" != " " } {
          return "$varr($compSqu)"
        }
      }
    }
  } else {
    if { "$morder($theWord)" == "D" } {
      set ourSqu [expr {$oorder($theWord) + ($thePos - 1) * $sqsize}]
      set compSqu [expr {$ourSqu - 1}]
      if { "$compSqu" > "0" } {
        if { "$varr($compSqu)" != "" && "$varr($compSqu)" != " " } {
          return "$varr($compSqu)"
        }
      }
    } else {
      set ourSqu [expr {$oorder($theWord) + ($thePos - 1) * 1}]
      set compSqu [expr {$ourSqu - $sqsize}]
      if { "$compSqu" > "0" } {
        if { "$varr($compSqu)" != "" && "$varr($compSqu)" != " " } {
          return "$varr($compSqu)"
        }
      }
    }
  }
  return "$retVal"
}

proc afterThisWordFixParticularSquares {theWord} {
global aorder valoks varr prenono sqsize xc xorder

#if { "$xorder($theWord)" == "29A" } {
#strategics2
#}

set thisWord [expr {$theWord}]
set valset(1) ""
#puts "thisWord=$thisWord xorder($thisWord)=$xorder($thisWord) aorder($thisWord)=$aorder($thisWord)"
if { "$aorder($thisWord)" != "" && [ourstringfirst $aorder($thisWord) "D" 0] < 0 && [ourstringfirst $aorder($thisWord) "A" 0] < 0 } {
foreach squ "$aorder($thisWord)" {
#puts "squ=$squ aorder($thisWord)=$aorder($thisWord) varr([expr {$squ}])=$varr([expr {$squ}]) valoks($thisWord)=$valoks($thisWord)"

if { $varr([expr {$squ}]) == " " || $varr([expr {$squ}]) == "" } {

set ivalset 0
if { "$valoks($thisWord)" != "" } {
#puts " yes squ=$squ aorder($thisWord)=$aorder($thisWord) varr([expr {$squ}])=$varr([expr {$squ}]) valoks($thisWord)=$valoks($thisWord)"
set apos [expr {($squ + 1) % $sqsize}]
foreach ourval "$valoks($thisWord)" {
set ivalset [expr {$ivalset + 1}]
set valset([expr {$ivalset}]) $ourval

set prevsqval "e"
set nextsqval "e"
#puts " yes $ourval squ=$squ aorder($thisWord)=$aorder($thisWord) varr([expr {$squ}])=$varr([expr {$squ}]) valoks($thisWord)=$valoks($thisWord)"

if { "$apos" == "$sqsize" } {
   if { "$varr([expr {$squ - 1}])" != " " } {
   set prevsqval "$varr([expr {$squ - 1}])"
   } else {
     if { [expr {$squ}] > [expr {$sqsize}] } {
   if { "$varr([expr {$squ - $sqsize}])" != " " } {
   set prevsqval "$varr([expr {$squ - $sqsize}])"
   }
     }
   }
   
} else {
if { "$squ" == "1" } {
   if { "$varr([expr {$squ + 1}])" != " " } {
   set nextsqval "$varr([expr {$squ + 1}])"
   } else {
     if { [expr {$squ + $sqsize}] <= [expr {$sqsize * $sqsize}] } {
   if { "$varr([expr {$squ + $sqsize}])" != " " } {
   set nextsqval "$varr([expr {$squ + $sqsize}])"
   }
     }
   }
} else {
   if { "$varr([expr {$squ - 1}])" != " " } {
   set prevsqval "$varr([expr {$squ - 1}])"
   } else {
     if { [expr {$squ}] > [expr {$sqsize}] } {
   if { "$varr([expr {$squ - $sqsize}])" != " " } {
   set prevsqval "$varr([expr {$squ - $sqsize}])"
   }
     }
   }
   if { [expr {$squ + 1}] <= [expr {$sqsize * $sqsize}] } {
   if { "$varr([expr {$squ + 1}])" != " " } {
   set nextsqval "$varr([expr {$squ + 1}])"
   } else {
     if { [expr {$squ + $sqsize}] <= [expr {$sqsize * $sqsize}] } {
   if { "$varr([expr {$squ + $sqsize}])" != " " } {
   set nextsqval "$varr([expr {$squ + $sqsize}])"
   }
     }
   }
   }
}
}

set i [expr {1+round(rand() * [expr {$ivalset - 1}])}]

set result "0"
set tries 0

while { "$result" == "0" } {
  set tries [expr {$tries + 1}]
  set result "1"
  
  # for whatever reason set result "0" for bad things below

if { "$tries" != "100" } {
       
       set relevant 1
       set sc ";"
       if { [string length "xxxxxxxxx"] <= 1 } {
		 set sc ""        
       }
       
       foreach bhg $prenono("$nextsqval") {
       if { "$bhg" == "$sc" } {
       set relevant 0
       }
       if { "$relevant" != "0" } {
       if { "$bhg" == "$valset($i)" } {
       set result 0
       }
       }
       }
       
       set relevant 1
       set sc ";"
       if { [string length "x"] <= 1 } {
		 set sc ""        
       }

       foreach bhg $prenono("$valset($i)") {
       if { "$bhg" == "$sc" } {
       set relevant 0
       }
       if { "$relevant" != "0" } {
       if { "$bhg" == "$prevsqval" } {
       set result 0
       }
       }
       }
       }
       
       if { "$squ" >= "200" && ("$xc([expr {64 + $i}])" == "Q" || "$xc([expr {64 + $i}])" == "J") } {
		set result 0
       }
  
  if { "$result" == "0" && "$tries" != "100" } {
    set i [expr {1+round(rand() * [expr {$ivalset - 1}])}]
    #puts "new i=$i ivalset=$ivalset $prevsqval$valset($i)$nextsqval"
  } 
  # end of

}
    #puts "square $squ surroundings $prevsqval$valset($i)$nextsqval"
#setWorder 0 0 $valset($i) $squ



}
    #puts "square $squ surroundings $prevsqval$valset($i)$nextsqval"
setWorder 0 0 $valset($i) $squ
}
}
}
}
  
}

proc squareIs {thisOne thisWord} {
  global oorder morder maps sqsize
       if { "$morder([expr {$maps($thisWord)}])" == "D" } {
         return [expr {$oorder($maps($thisWord)) + ($thisOne - 1) * $sqsize}]
       } 
       return [expr {$oorder($maps($thisWord)) + ($thisOne - 1) * 1}]
}

proc sWord {cWord iij} {
global desperateword desperatecount maps numthings
global desperatecontents desperatereveal morder sqsize mode
global desperateclue worder corder desperaterating oorder xorder sorder varr arr zarr

        #puts "Corder($maps($iij))=$corder($maps($iij)) morder($maps($iij))=$morder($maps($iij))  worder($maps($iij))=$worder($maps($iij))"


       if { "$morder([expr {$maps($iij)}])" == "D" } {
        set ourpos 0
        for {set iii $oorder([expr {$maps($iij)}])} {$iii < ([expr {$oorder([expr {$maps($iij)}]) + $sorder([expr {$maps($iij)}]) * $sqsize}])} {set iii [expr $iii+$sqsize]} {

         set iind 0
         
         set ourpos [expr {$ourpos + 1}]
         
         if { "$zarr([eval {squareIs $ourpos $maps($iij)}])" == "" } {
         
              set cwl [eval {checkWordLetter "$cWord" $sorder($maps($iij)) $ourpos}]
              set varr($iii) $cwl
         } else {

              set cwl [eval {checkWordLetter "$cWord" $sorder($maps($iij)) $ourpos}]
              setWorder $maps($iij) $ourpos $cwl $iii

         
         #foreach qw "$zarr($maps($iij))" {
          # set iind [expr {$iind + 1}]
           #set ourpos 0
           #set jind 0
           #foreach qqw "$yarr($maps($iij))" {
            #set jind [expr {$jind + 1}]
            #if { "$jind" == "$iind" } {
             # set ourpos $qqw
              #set cwl [eval {checkWordLetter "$cWord" $sorder($maps($iij)) [expr {$iii - $oorder([expr {$maps($iij)}]) + 1}]}]
              #setWorder $qw $ourpos $cwl $iii
            #}
           #}
         
         #}
         }

        }
       } else {
        set ourpos 0
        for {set iii $oorder([expr {$maps($iij)}])} {$iii < ([expr {$oorder([expr {$maps($iij)}]) + $sorder([expr {$maps($iij)}])}])} {set iii [expr $iii+1]} {

         set iind 0
         set ourpos [expr {$ourpos + 1}]
         
         if { "$zarr($iii)" == "" } {
        # puts "Here for $maps($iij) ... cWord=$cWord ourpos=$ourpos"
              set cwl [eval {checkWordLetter "$cWord" $sorder($maps($iij)) $ourpos}]
        # puts "re Here for $maps($iij) ... cWord=$cWord ourpos=$ourpos cwl=$cwl"
              set varr($iii) $cwl
         } else {
       #  puts "vs Here for $maps($iij) ... cWord=$cWord ourpos=$ourpos"
              set cwl [eval {checkWordLetter "$cWord" $sorder($maps($iij)) $ourpos}]
       #  puts "re vs Here for $maps($iij) ... cWord=$cWord ourpos=$ourpos cwl=$cwl"
              setWorder $maps($iij) $ourpos $cwl $iii
         #foreach qw "$zarr($maps($iij))" {
         #  set iind [expr {$iind + 1}]
         #  set ourpos 0
         #  set jind 0
         #  foreach qqw "$yarr($maps($iij))" {
          #  set jind [expr {$jind + 1}]
           # if { "$jind" == "$iind" } {
           #   set ourpos $qqw
            #  set cwl [eval {checkWordLetter "$cWord" $sorder($maps($iij)) [expr {$iii - $oorder([expr {$maps($iij)}]) + 1}]}]
            #  setWorder $qw $ourpos $cwl $iii
            #}
           #}
         
         #}
         }

        }
        }
       
  
  for {set iii 1} {$iii <= $sqsize} {set iii [expr $iii+1]} {
  set cline ""
  for {set jjj 1} {$jjj <= $sqsize} {set jjj [expr $jjj+1]} {
  set cline "$cline$varr([expr {($iii - 1) * $sqsize + $jjj}])"
  }
  #puts $cline
  }


  for {set iii 1} {$iii <= $numthings} {set iii [expr $iii+1]} {
  if { "$desperateword" == "$maps($iii)" } {
    puts "Clue for $xorder($maps($iii)) is ... $corder($maps($iii))"
  #} else {
    #puts "$iii Clue $xorder($maps($iii)) $corder($maps($iii))"
  }
  }  


}


proc checkWordLetter {aWord aLen givenChar} {
#puts "checking $aWord RE $aLen in length for $givenChar ..."
  global desperateword sorder
  set blah ""
  set ii 0
  set jj 0
  set retChar ""
  for {set iijj 0} {$iijj < [string length $aWord]} {set iijj [expr $iijj+1]} {
    if { [string range $aWord $iijj $iijj] >= "A" && [string range $aWord $iijj $iijj] <= "Z" } {
      set ii [expr {$ii + 1}]
      set jj [expr {$jj + 1}]
      if { "$ii" == "$givenChar" } {
#puts "ii=$ii vs givenChar=$givenChar"
        set retChar [string range $aWord $iijj $iijj]
      }
    } else {
      if { "$blah" == "" } {
       set blah "$jj"
       if { [expr {$jj}] <= $sorder($desperateword) } {
       set blah "$sorder($desperateword)"
       }
      } else {
       set blah "$blah,$jj"
      }
      set jj 0
    }
  }
  
  if { "$ii" == "$aLen" } {
    if { "$blah" == "" } {
     return "$retChar"
    } else {
     return "$retChar"
    }
  } else {
  #puts "Oops"
    return " "
  }

}


proc getRandomAcronym {ourHtml} {
  set cluepart ""
     
        set finding(1) ""
        set afind 0
        set num 0
        set ifind 0
        set afind [ourstringfirst $ourHtml ". <a href=\"/?w" $afind]
        
        if { [expr {($afind)}] > 0 } {
          set afind "1"
        }

        while { [expr {($afind)}] >= 0 } {
          set afind [ourstringfirst $ourHtml ". <a href=\"/?w" $afind]
          #puts "afind=$afind"
          if { [expr {($afind)}] > 0 } {
            set num [expr {$num + 1}]
            set afindend [ourstringfirst $ourHtml "</a>" $afind]
          #puts "afindend=$afindend xLen=$xLen"
#160. <a href="/?w=wier-cook+airport">wier-cook airport</a><br>
#161. <a href="/?w=wier+cook+airport">wier cook airport</a><br>


            set afindmid [expr {0 - 1}]
            set maybe [string range $ourHtml $afind [expr {$afindend - 1}]]
            set iixx [eval {ourstringfirst $maybe "." 0}]
            if { [expr {($iixx)}] < 0 } {
              set afindmid [eval {ourstringfirst $maybe ">" 0}]
            }
            
            if  { [expr {($afindmid)}] < 0 } {
              set ifind [expr {$ifind + 1}]
              set finding($ifind) [string range $maybe [expr {$afindmid + 1}] 1000]
            }

           
          }
        }
        
		if { "$ifind" != "0" } {
         set ig [expr {1 + round(rand() * [expr {$ifind - 1}])}]
		 set cluepart $finding($ig)  
		}
  
  return "$cluepart"
  
}
 
proc lookForTwoAcronyms {ourWord} {
        global worder corder sorder desperatereveal
     
        set xLen $sorder($ourWord)
     
        set pref "/?w=expand%3A"
        set suff "&ls=b"
        set url "http://www.onelook.com/$pref$worder($ourWord)$suff"
        #puts "trying arcronym url=$url"
        if {[catch {set r [http::geturl $url -binary 1]} err]} { return $err }
        if {[catch {set html [http::data $r]} err]} { set html " " }
        set clue [eval {getRandomAcronym $html}]
        if { "$clue" != "" } {
          set corder($ourWord) "$clue ($sorder($ourWord))"
     set desperatereveal "n"
          return "$clue"
        } else {
          set half [expr {round($sorder($ourWord) / 2)}]
          set firstbit [string range $worder($ourWord) 0 [expr {$half - 1}]]
          set url "http://www.onelook.com/$pref$firstbit$suff"
        #puts "trying arcronym1 url=$url"
          if {[catch {set r [http::geturl $url -binary 1]} err]} { return $err }
          if {[catch {set html [http::data $r]} err]} { set html " " }
        
          set clue [eval {getRandomAcronym $html}]
          if { "$clue" == "" } {
            return ""
          } else {
            set secondbit [string range $worder($ourWord) [expr {$half - 0}] 1000]
            set url "http://www.onelook.com/$pref$secondbit$suff"
        #puts "trying arcronym2 url=$url"
            if {[catch {set r [http::geturl $url -binary 1]} err]} { return $err }
            if {[catch {set html [http::data $r]} err]} { set html " " }
        
            set cluetwo [eval {getRandomAcronym $html}]
            if { "$cluetwo" == "" } {
              return ""
            } else {
              set commasp ", "
              set comma ","
              set halftwo [expr {$xLen - $half}]
              set corder($ourWord) "$clue$commasp$cluetwo ($half$comma$halftwo)"
     set desperatereveal "n"
              return $corder($ourWord)
            }
          }
          
        }
  
}

proc thereIsAlwaysAClue {} {
global desperateword desperatecount desperatebackup
global desperatecontents desperatereveal
global desperateclue worder corder desperaterating sorder

set i $desperateword
set n $sorder($i)

set prevletter "E"
set thisWord ""

if { "$desperatebackup" != "" } {
 set baseword "$desperatebackup"
 set n [string length "$baseword"]
} else {
 set baseword "$worder($i)"
}

set ourclue "Check neighbourly/repetative phone touchpad number "
for {set iijj 0} {$iijj < $n} {set iijj [expr $iijj+1]} {
    set thisletter [string range $baseword $iijj $iijj]
    if { "$thisletter" >= "A" && "$thisletter" <= "Z" } {
      foreach xq "AB22 ED33 IG44 ON66 UT88 YU98 BA22 CA22 DE33 FE33 GI44 HI44 JI54 KI54 LI54 MO66 NO66 PO76 QU78 RU78 SU78 TU88 VU88 WU98 XY99 ZY99" {
		set hhh [ourstringfirst $thisletter [string range $xq 0 0] 0]
		if { [expr {($hhh)}] >= 0 } {
         set thisnumber [string range $xq 2 2]
         set ourclue "$ourclue$thisnumber"
         set thisWord "$thisWord$thisletter"
		}
      }
    } else {
      if { "$baseword" != "$desperatebackup" } {
      foreach xq "AB22 ED33 IG44 ON66 UT88 YU98 BA22 CA22 DE33 FE33 GI44 HI44 JI54 KI54 LI54 MO66 NO66 PO76 QU78 RU78 SU78 TU88 VU88 WU98 XY99 ZY99" {
		set hhh [ourstringfirst $prevletter [string range $xq 0 0] 0]
		if { [expr {($hhh)}] >= 0 } {
         set thisletter [string range $xq 1 1]
         set thisnumber [string range $xq 3 3]
         set ourclue "$ourclue$thisnumber"
         set thisWord "$thisWord$thisletter"
		}
      }
      }
    }
    set prevletter "$thisletter" 
}

set worder($i) "$thisWord"
set corder($i) "$ourclue ? ($sorder($i))"

lookForTwoAcronyms $i
set desperatebackup ""
return "$thisWord"
}


proc checkWord {aWord aLen callPlace} {
global desperateword desperatecount
global desperatecontents desperatereveal
global desperateclue worder corder desperaterating sorder

if { "$aWord" == "" } {
#puts "hope we are not stuck at $callPlace $desperatecount ?"

set desperatecount [expr {($desperatecount + 1) % 300}]

if { "$desperatecount" == "30" } {
   if { "$desperatecontents" != "" } {
     set worder($desperateword) "$desperatecontents"
     set corder($desperateword) "$desperateclue"
     set aWord "$desperatecontents"
     set desperatereveal "y"
     set desperatecontents ""
     set desperaterating 0
     lookForTwoAcronyms $desperateword

   } else { 
   
     set aWord [eval {thereIsAlwaysAClue}]
     set desperatereveal "n"
     set desperatecontents ""
     set desperaterating 0
   }
   set worder($desperateword) "$aWord"
   sWord $aWord $desperateword
   set desperatebackup ""
   return " "
}
  return "n"
}

set desperatecount 0

#puts "checking if $aWord is $aLen in length ..."
  set blah ""
  set ii 0
  set jj 0
  for {set iijj 0} {$iijj < [string length $aWord]} {set iijj [expr $iijj+1]} {
    if { [string range $aWord $iijj $iijj] >= "A" && [string range $aWord $iijj $iijj] <= "Z" } {
      set ii [expr {$ii + 1}]
      set jj [expr {$jj + 1}]
    } else {
      if { "$blah" == "" } {
       set blah "$jj"
       if { [expr {$jj}] <= $sorder($desperateword) } {
       set blah "$sorder($desperateword)"
       }
      } else {
       set blah "$blah,$jj"
      }
      set jj 0
    }
  }
  
  if { "$ii" == "$aLen" } {
    if { "$blah" == "" } {
   set desperatebackup ""
     return "$jj"
    } else {
   set desperatebackup ""
     return "$blah,$jj"
    }
  } else {
  #puts "oops ... no way"
    return "n"
  }

}



set xc(65) "A"
set xc(66) "B"
set xc(67) "C"
set xc(68) "D"
set xc(69) "E"
set xc(70) "F"
set xc(71) "G"
set xc(72) "H"
set xc(73) "I"
set xc(74) "J"
set xc(75) "K"
set xc(76) "L"
set xc(77) "M"
set xc(78) "N"
set xc(79) "O"
set xc(80) "P"
set xc(81) "Q"
set xc(82) "R"
set xc(83) "S"
set xc(84) "T"
set xc(85) "U"
set xc(86) "V"
set xc(87) "W"
set xc(88) "X"
set xc(89) "Y"
set xc(90) "Z"


set strategicsquarelist "46 48 50 52 82 86 106 110 118 120 179"
set strategicletterlist "65 68 69 73 76 77 78 79 82 83 84 89"

proc strategics {} {
global varr strategicsquarelist strategicletterlist xc mode sqsize prenono
 set good(1) "65"
 set igood 0
 set valset(1) ""
 set nextsqval "e"
 set prevsqval "e"
 foreach huh "$strategicletterlist" {
  set igood [expr {$igood + 1}]
  set good($igood) "$huh"
 }
 foreach squ "$strategicsquarelist" {
  if { "$varr($squ)" == " " || "$varr($squ)" == "" } {
if { "$squ" == "1" } {
   if { "$varr([expr {$squ + 1}])" != " " } {
   set nextsqval "$varr([expr {$squ + 1}])"
   } else {
     if { [expr {$squ + $sqsize}] <= [expr {$sqsize * $sqsize}] } {
   if { "$varr([expr {$squ + $sqsize}])" != " " } {
   set nextsqval "$varr([expr {$squ + $sqsize}])"
   }
     }
   }
} else {
   if { "$varr([expr {$squ - 1}])" != " " } {
   set prevsqval "$varr([expr {$squ - 1}])"
   } else {
     if { [expr {$squ}] > [expr {$sqsize}] } {
   if { "$varr([expr {$squ - $sqsize}])" != " " } {
   set prevsqval "$varr([expr {$squ - $sqsize}])"
   }
     }
   }
   if { [expr {$squ + 1}] <= [expr {$sqsize * $sqsize}] } {
   if { "$varr([expr {$squ + 1}])" != " " } {
   set nextsqval "$varr([expr {$squ + 1}])"
   } else {
     if { [expr {$squ + $sqsize}] <= [expr {$sqsize * $sqsize}] } {
   if { "$varr([expr {$squ + $sqsize}])" != " " } {
   set nextsqval "$varr([expr {$squ + $sqsize}])"
   }
     }
   }
   }
}

    set i [expr {1+round(rand() * [expr {$igood - 1}])}]
    


set result "0"
set tries 0

while { "$result" == "0" } {
  set tries [expr {$tries + 1}]
  set result "1"
  
  # for whatever reason set result "0" for bad things below

if { "$tries" != "100" } {
       
       set relevant 1
       set sc ";"
       if { [string length "xxxxxxxxx"] <= 1 } {
		 set sc ""        
       }
       
       foreach bhg $prenono("$nextsqval") {
       if { "$bhg" == "$sc" } {
       set relevant 0
       }
       if { "$relevant" != "0" } {
       if { "$bhg" == "$xc([expr {64 + $i}])" } {
       set result 0
       }
       }
       }
       
       set relevant 1
       set sc ";"
       if { [string length "x"] <= 1 } {
		 set sc ""        
       }

       foreach bhg $prenono("$xc([expr {64 + $i}])") {
       if { "$bhg" == "$sc" } {
       set relevant 0
       }
       if { "$relevant" != "0" } {
       if { "$bhg" == "$prevsqval" } {
       set result 0
       }
       }
       }
       }
       
       if { "$squ" >= "200" && ("$xc([expr {64 + $i}])" == "Q" || "$xc([expr {64 + $i}])" == "J") } {
		set result 0
       }
  
  if { "$result" == "0" && "$tries" != "100" } {
    set i [expr {1+round(rand() * [expr {$igood - 1}])}]
    #puts "new i=$i ivalset=$ivalset $prevsqval$valset($i)$nextsqval"
  } 
  # end of

}
    
    setWorder 0 0 $xc($good($i)) $squ
  }
 }
}


#set strategicsquare2list "1 3 5 7 9 11 13 16 18 20 22 24 26 28    196 198 200 202 204 206 208 210     211 213 215 217 219 221 223 225"
#set strategicletter2list "65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90"
set strategicsquare2list "18 48 54 56 58 77 82 107 110 116 118 120 138 142 144 149 168 170 -172 174 176 178 180 202"
set strategicletter2list "69 76 78 82 83 84 65 73 79"
set strategicletter2endlist "69 76 78 82 83 84"

proc strategics2 {} {
global varr strategicsquare2list  strategicletter2endlist strategicletter2list xc mode sqsize prenono
 set good(1) "69"
 set xgood(1) "69"
 set valset(1) ""
 set nextsqval "e"
 set prevsqval "e"
 set igood 0
 set jgood 0
 foreach huh "$strategicletter2list" {
  set igood [expr {$igood + 1}]
  set good($igood) "$huh"
 }
 foreach huh "$strategicletter2endlist" {
  set jgood [expr {$jgood + 1}]
  set xgood($jgood) "$huh"
 }
 foreach squ "$strategicsquare2list" {
 set isneg ""
 if { [expr {($squ)}] < 0 } {
   set squ [expr {0 - ($squ)}]
   set isneg "y"
 }
  if { "$varr($squ)" == " " || "$varr($squ)" == "" } {
if { "$squ" == "1" } {
   if { "$varr([expr {$squ + 1}])" != " " } {
   set nextsqval "$varr([expr {$squ + 1}])"
   } else {
     if { [expr {$squ + $sqsize}] <= [expr {$sqsize * $sqsize}] } {
   if { "$varr([expr {$squ + $sqsize}])" != " " } {
   set nextsqval "$varr([expr {$squ + $sqsize}])"
   }
     }
   }
} else {
   if { "$varr([expr {$squ - 1}])" != " " } {
   set prevsqval "$varr([expr {$squ - 1}])"
   } else {
     if { [expr {$squ}] > [expr {$sqsize}] } {
   if { "$varr([expr {$squ - $sqsize}])" != " " } {
   set prevsqval "$varr([expr {$squ - $sqsize}])"
   }
     }
   }
   if { [expr {$squ + 1}] <= [expr {$sqsize * $sqsize}] } {
   if { "$varr([expr {$squ + 1}])" != " " } {
   set nextsqval "$varr([expr {$squ + 1}])"
   } else {
     if { [expr {$squ + $sqsize}] <= [expr {$sqsize * $sqsize}] } {
   if { "$varr([expr {$squ + $sqsize}])" != " " } {
   set nextsqval "$varr([expr {$squ + $sqsize}])"
   }
     }
   }
   }
}

    if { "$isneg" == "y" } {
    set i [expr {1+round(rand() * [expr {$jgood - 1}])}]
    } else {
    set i [expr {1+round(rand() * [expr {$igood - 1}])}]
    }
    


set result "0"
set tries 0

while { "$result" == "0" } {
  set tries [expr {$tries + 1}]
  set result "1"
  
  # for whatever reason set result "0" for bad things below

if { "$tries" != "100" } {
       
       set relevant 1
       set sc ";"
       if { [string length "xxxxxxxxx"] <= 1 } {
		 set sc ""        
       }
       
       foreach bhg $prenono("$nextsqval") {
       if { "$bhg" == "$sc" } {
       set relevant 0
       }
       if { "$relevant" != "0" } {
       if { "$bhg" == "$xc([expr {$good($i)}])" } {
       set result 0
       }
       }
       }
       
       set relevant 1
       set sc ";"
       if { [string length "x"] <= 1 } {
		 set sc ""        
       }

       foreach bhg $prenono("$xc([expr {$good($i)}])") {
       if { "$bhg" == "$sc" } {
       set relevant 0
       }
       if { "$relevant" != "0" } {
       if { "$bhg" == "$prevsqval" } {
       set result 0
       }
       }
       }
       }
       
       if { "$squ" >= "196" && ("$xc([expr {$good($i)}])" == "Q" || "$xc([expr {$good($i)}])" == "J") } {
		set result 0
       }
  
  if { "$result" == "0" && "$tries" != "100" } {
    set i [expr {1+round(rand() * [expr {$igood - 1}])}]
    #puts "new i=$i ivalset=$ivalset $prevsqval$valset($i)$nextsqval"
  } 
  # end of

}
    
    setWorder 0 0 $xc([expr {$good($i)}]) $squ
  }
 }
}

proc setWorder {whichWord whichPos withWhichCharacter whichSquare} {
  global worder sorder varr yarr zarr xorder arr desperatereveal cone
  
# puts "whichSquare=$whichSquare whichWord=$whichWord whichPos=$whichPos withWhichCharacter=$withWhichCharacter zarr($whichSquare)=$zarr($whichSquare)"

if { "$whichWord" != "0" } {  
      #puts "old worder($whichWord)=$worder($whichWord)"
      #set neww ""
      #for {set j 0} {$j < [string length "$worder($whichWord)"]} {set j [expr $j+1]} {
      #if { [string range "$worder($whichWord)" $j $j] != "+" } {
       # set letter [string range $worder($whichWord) $j $j]
       # set neww "$neww$letter"
      #}
      #}
      #set worder($whichWord) "$neww"
      
      #puts "new worder($whichWord)=$worder($whichWord)"

  if { "$whichPos" > "1" } {
    set prefix [string range $worder($whichWord) 0 [expr {$whichPos - 2}]]    
  } else {
    set prefix ""
  }
  
  if { "$whichPos" != [string length $worder($whichWord)] } {
    set suffix [string range $worder($whichWord) [expr {$whichPos - 1}] [expr {[string length $worder($whichWord)] - 1}]]    
  } else {
    set suffix ""
  }
  
  set worder($whichWord) [string range "$prefix$withWhichCharacter$suffix" 0 $sorder($whichWord)]
}
  set varr($whichSquare) "$withWhichCharacter"
  if { "$desperatereveal" == "y" } {
    set arr($whichSquare) "$cone($whichSquare)$withWhichCharacter"
  }
  
  if { "$zarr($whichSquare)" != "" && "$zarr($whichSquare)" != " " } {
  
    set whichSnake 0
    foreach another "$zarr($whichSquare)" {
      set whichSnake [expr {$whichSnake + 1}]
      if { $another != $whichWord } {
    set thisSnake 0
        foreach anotherp "$yarr($whichSquare)" {
          set thisSnake [expr {$thisSnake + 1}]
          if { $thisSnake == $whichSnake } {
  
  #if { "$withWhichCharacter" != "" && "$withWhichCharacter" != " " } {
  #puts "before whichWord=$another whichPos=$anotherp $withWhichCharacter $xorder($another) $sorder($another) worder($another)=$worder($another)?"
  #}
  if { "$anotherp" > "1" } {
    set prefix "[string range $worder($another) 0 [expr {$anotherp - 2}]]"    
  } else {
    set prefix ""
  }
  
  if { "$anotherp" != [string length $worder($another)] } {
    set suffix "[string range $worder($another) [expr {$anotherp - 1*0}] [expr {[string length $worder($another)] - 1}]]"    
  } else {
    set suffix ""
  }
  
  if { "$withWhichCharacter" != "" && "$withWhichCharacter" != " " } {
  set worder($another) [string range "$prefix$withWhichCharacter$suffix" 0 [expr {$sorder($another) - 1}]]
  #puts "after whichWord=$another whichPos=$anotherp $withWhichCharacter $xorder($another) $sorder($another)  worder($another)=$worder($another)?"
  }           
          }
        }
      }
    }
  
  }
  
}


set talk ""

set fournum 0
set fivenum 0
set sixnum 0
set sevennum 0
set eightnum 0
set ninenum 0
set fifteennum 0

set fourlist(1) ""
set fivelist(1) ""
set sixlist(1) ""
set sevenlist(1) ""
set eightlist(1) ""
set ninelist(1) ""
set fifteenlist(1) ""


proc alttry {altword altlen} {
  global sorder worder fourlist fournum fivelist fivenum sixlist sixnum sevenlist sevennum eightlist eightnum ninelist ninenum fifteenlist fifteennum
  set vs [expr {0 - 1}]
  if { "$vs" != "0" } {
    if { [expr {$altlen}] == 15 } {
    set vs $fifteennum
    } else {
    if { [expr {$altlen}] == 9 } {
    set vs $ninenum
    } else {
    if { [expr {$altlen}] == 8 } {
    set vs $eightnum
    } else {
    if { [expr {$altlen}] == 7 } {
    set vs $sevennum
    } else {
    if { [expr {$altlen}] == 6 } {
    set vs $sixnum
    } else {
    if { [expr {$altlen}] == 5 } {
    set vs $fivenum
    } else {
    if { [expr {$altlen}] == 4 } {
    set vs $fournum
    }
    }
    }
    }
    }
    }
    }
    
    if { [expr {$altlen}] == 15 } {
     for {set i 1} {$i <= $fifteennum} {set i [expr $i+1]} {
      set match 1
      for {set j 0} {$j < $altlen} {set j [expr $j+1]} {
       if { [string range $fifteenlist($i) $j $j] != [string range $altword $j $j] && [string range $altword $j $j] != "+" } {
        set match 0
       }
      }
      if { $match == 1 } {
       return $fifteenlist($i)
      }
     }
    } else {
    if { [expr {$altlen}] == 9 } {
     for {set i 1} {$i <= $ninenum} {set i [expr $i+1]} {
      set match 1
      for {set j 0} {$j < $altlen} {set j [expr $j+1]} {
       if { [string range $ninelist($i) $j $j] != [string range $altword $j $j] && [string range $altword $j $j] != "+" } {
        set match 0
       }
      }
      if { $match == 1 } {
       return $ninelist($i)
      }
     }
    } else {
    if { [expr {$altlen}] == 8 } {
     for {set i 1} {$i <= $eightnum} {set i [expr $i+1]} {
      set match 1
      for {set j 0} {$j < $altlen} {set j [expr $j+1]} {
       if { [string range $eightlist($i) $j $j] != [string range $altword $j $j] && [string range $altword $j $j] != "+" } {
        set match 0
       }
      }
      if { $match == 1 } {
       return $eightlist($i)
      }
     }
    } else {
    if { [expr {$altlen}] == 7 } {
     for {set i 1} {$i <= $sevennum} {set i [expr $i+1]} {
      set match 1
      for {set j 0} {$j < $altlen} {set j [expr $j+1]} {
       if { [string range $sevenlist($i) $j $j] != [string range $altword $j $j] && [string range $altword $j $j] != "+" } {
        set match 0
       }
      }
      if { $match == 1 } {
       return $sevenlist($i)
      }
     }
    } else {
    if { [expr {$altlen}] == 6 } {
     for {set i 1} {$i <= $sixnum} {set i [expr $i+1]} {
      set match 1
      for {set j 0} {$j < $altlen} {set j [expr $j+1]} {
       if { [string range $sixlist($i) $j $j] != [string range $altword $j $j] && [string range $altword $j $j] != "+" } {
        set match 0
       }
      }
      if { $match == 1 } {
       return $sixlist($i)
      }
     }
    } else {
    if { [expr {$altlen}] == 5 } {
     for {set i 1} {$i <= $fivenum} {set i [expr $i+1]} {
      set match 1
      for {set j 0} {$j < $altlen} {set j [expr $j+1]} {
       if { [string range $fivelist($i) $j $j] != [string range $altword $j $j] && [string range $altword $j $j] != "+" } {
        set match 0
       }
      }
      if { $match == 1 } {
       return $fivelist($i)
      }
     }
    } else {
    if { [expr {$altlen}] == 4 } {
     for {set i 1} {$i <= $fournum} {set i [expr $i+1]} {
      set match 1
      #puts "fourlist($i)=$fourlist($i)"
      for {set j 0} {$j < $altlen} {set j [expr $j+1]} {
       if { [string range $fourlist($i) $j $j] != [string range $altword $j $j] && [string range $altword $j $j] != "+" } {
        set match 0
       }
      }
      if { $match == 1 } {
       return $fourlist($i)
      }
     }
    }
    }
    }
    }
    }
    }
    }
  }
  #puts "no match for $altword of length $altlen"
  return ""
}

proc pickoneout {whichguy} {
  global sorder worder fourlist fournum fivelist fivenum sixlist sixnum sevenlist sevennum eightlist eightnum ninelist ninenum fifteenlist fifteennum
  set vs $fifteennum
  if { "$vs" != "0" } {
    if { [expr {$sorder($whichguy)}] == 15 } {
    set vs $fifteennum
    } else {
    if { [expr {$sorder($whichguy)}] == 9 } {
    set vs $ninenum
    } else {
    if { [expr {$sorder($whichguy)}] == 8 } {
    set vs $eightnum
    } else {
    if { [expr {$sorder($whichguy)}] == 7 } {
    set vs $sevennum
    } else {
    if { [expr {$sorder($whichguy)}] == 6 } {
    set vs $sixnum
    } else {
    if { [expr {$sorder($whichguy)}] == 5 } {
    set vs $fivenum
    } else {
    set vs $fournum
    }
    }
    }
    }
    }
    }
    
    set ourx [expr {1+round(rand()*[expr {$vs - 1}])}]
    
    if { [expr {$sorder($whichguy)}] == 15 } {
    set worder($whichguy) $fifteenlist($ourx)
    } else {
    if { [expr {$sorder($whichguy)}] == 9 } {
    set worder($whichguy) $ninelist($ourx)
    } else {
    if { [expr {$sorder($whichguy)}] == 8 } {
    set worder($whichguy) $eightlist($ourx)
    } else {
    if { [expr {$sorder($whichguy)}] == 7 } {
    set worder($whichguy) $sevenlist($ourx)
    } else {
    if { [expr {$sorder($whichguy)}] == 6 } {
    set worder($whichguy) $sixlist($ourx)
    } else {
    if { [expr {$sorder($whichguy)}] == 5 } {
    set worder($whichguy) $fivelist($ourx)
    } else {
    set worder($whichguy) $fourlist($ourx)
    }
    }
    }
    }
    }
    }
    
  } else {
    populatelist
  }
}


proc isNextSquareNotControversial {thisPos thisWord} {
  global mode sqsize varr oorder morder
  set retVal 1
  
  if { "$morder($thisWord)" == "A" } {
  set squ [expr {$oorder($thisWord) + ($thisPos - 1)}]
  } else {
  set squ [expr {$oorder($thisWord) + ($thisPos - 1) * $sqsize}]
  }
  
  set prevsqval " "
  set nextsqval " "
  
if { "$squ" == "1" } {
   if { "$varr([expr {$squ + 1}])" != " " } {
   set nextsqval "$varr([expr {$squ + 1}])"
   } else {
     if { [expr {$squ + $sqsize}] <= [expr {$sqsize * $sqsize}] } {
   if { "$varr([expr {$squ + $sqsize}])" != " " } {
   set nextsqval "$varr([expr {$squ + $sqsize}])"
   }
     }
   }
} else {
   if { [expr {$squ}] <= [expr {$sqsize * $sqsize}] } {
   if { "$varr([expr {$squ - 1}])" != " " } {
   set prevsqval "$varr([expr {$squ - 1}])"
   } else {
     if { [expr {$squ}] > [expr {$sqsize}] } {
   if { "$varr([expr {$squ - $sqsize}])" != " " } {
   set prevsqval "$varr([expr {$squ - $sqsize}])"
   }
     }
   }
   if { [expr {$squ + 1}] <= [expr {$sqsize * $sqsize}] } {
   if { "$varr([expr {$squ + 1}])" != " " } {
   set nextsqval "$varr([expr {$squ + 1}])"
   } else {
     if { [expr {$squ + $sqsize}] <= [expr {$sqsize * $sqsize}] } {
   if { "$varr([expr {$squ + $sqsize}])" != " " } {
   set nextsqval "$varr([expr {$squ + $sqsize}])"
   }
     }
   }
   }
   }
}
  
  if { "$prevsqval" != " " || "$nextsqval" != " " } {
    set retval 0
  }
  
  return $retVal
}

proc extraIntelligence {ourguess ourword ourlen ourda} {
   global worder sorder varr
   set outguess "$ourguess"
   if { "$ourda" == "13A" } {
     set huh [ourstringlast "$ourguess!" "%3F!" 0]
     if { [expr {($huh)}] > 0 } {
       set suff "@"
       set pref [string range "$ourguess" 0 [expr {$huh - 1}]]
       set outguess "$pref$suff"
     } else {
       set lastchar [string range "$ourguess" [expr {[string length "$ourguess"] - 1}]  [expr {[string length "$ourguess"] - 1}]]
       set ischar $varr([eval {squareIs $sorder($ourword) $ourword}])
       if { "$ischar" != "$lastchar" } {
         set huh [expr {[string length "$ourguess"] - 1}] 
         set suff "@"
         set pref [string range "$ourguess" 0 [expr {$huh - 1}]]
         set outguess "$pref$suff"
       }
     }
   } else {
   if { "$ourda" == "15A" } {
     set huh [ourstringlast "$ourguess!" "%3F!" 0]
     if { [expr {($huh)}] > 0 } {
       set suff "#"
       set pref [string range "$ourguess" 0 [expr {$huh - 1}]]
       set outguess "$pref$suff"
     } else {
       set lastchar [string range "$ourguess" [expr {[string length "$ourguess"] - 1}]  [expr {[string length "$ourguess"] - 1}]]
       set ischar $varr([eval {squareIs $sorder($ourword) $ourword}])
       if { "$ischar" != "$lastchar" } {
         set huh [expr {[string length "$ourguess"] - 1}] 
         set suff "#"
         set pref [string range "$ourguess" 0 [expr {$huh - 1}]]
         set outguess "$pref$suff"
       }
     }
     set huh [ourstringfirst "$outguess!" "%3F%3F%3F" 0]
     if { "$huh" == "0" } {
       set pref "%3F%3F"
       set midbit "@"
       set suff [string range "$outguess" 9 1000]
       set outguess "$pref$midbit$suff"
     } else {
     set huh [ourstringfirst "$outguess!" "%3F%3F" 0]
     if { "$huh" == "1" } {
       set pref [string range "$outguess" 0 0]
       set midbit "%3F@"
       set suff [string range "$outguess" 7 1000]
       set outguess "$pref$midbit$suff"
     } else {
     set huh [ourstringfirst "$outguess!" "%3F" 0]
     if { "$huh" == "2" } {
       set pref [string range "$outguess" 0 1]
       set midbit "@"
       set suff [string range "$outguess" 5 1000]
       set outguess "$pref$midbit$suff"
     } else {
     
     set huh [ourstringfirst "$outguess!" "**%3F" 0]
     if { "$huh" == "1" } {
       set pref [string range "$outguess" 0 0]
       set midbit "**%3F@"
       set suff [string range "$outguess" 9 1000]
       set outguess "$pref$midbit$suff"
     } else {
     set huh [ourstringfirst "$outguess!" "**%3F" 0]
     if { "$huh" == "2" } {
       set pref [string range "$outguess" 0 1]
       set midbit "**@"
       set suff [string range "$outguess" 7 1000]
       set outguess "$pref$midbit$suff"


}
     
     }
     }
     }
     }
   } else {
   if { "$ourda" == "25A" } {
     set huh [ourstringlast "$ourguess!" "%3F!" 0]
     if { [expr {($huh)}] > 0 } {
       set suff "@"
       set pref [string range "$ourguess" 0 [expr {$huh - 1}]]
       set outguess "$pref$suff"
     } else {
       set lastchar [string range "$ourguess" [expr {[string length "$ourguess"] - 1}]  [expr {[string length "$ourguess"] - 1}]]
       set ischar $varr([eval {squareIs $sorder($ourword) $ourword}])
       if { "$ischar" != "$lastchar" } {
         set huh [expr {[string length "$ourguess"] - 1}] 
         set suff "@"
         set pref [string range "$ourguess" 0 [expr {$huh - 1}]]
         set outguess "$pref$suff"
       }
     }
   } else {
   if { "$ourda" == "3D" } {
     set huh [ourstringlast "$ourguess!" "%3F!" 0]
     if { [expr {($huh)}] > 0 } {
       set suff "@"
       set pref [string range "$ourguess" 0 [expr {$huh - 1}]]
       set outguess "$pref$suff"
     } else {
       set lastchar [string range "$ourguess" [expr {[string length "$ourguess"] - 1}]  [expr {[string length "$ourguess"] - 1}]]
       set ischar $varr([eval {squareIs $sorder($ourword) $ourword}])
       if { "$ischar" != "$lastchar" } {
         set huh [expr {[string length "$ourguess"] - 1}] 
         set suff "@"
         set pref [string range "$ourguess" 0 [expr {$huh - 1}]]
         set outguess "$pref$suff"
       }
     }
   } else {
   if { "$ourda" == "9A" } {

     set huh [ourstringlast "$ourguess!" "%3F%3F%3F%3F%3F%3F%3F%3F%3F!" 0]
     if { [expr {($huh)}] > 0 } {
       set suff "@%3F@%3F%3F%3F%3F%3F@"
       set pref [string range "$ourguess" 0 [expr {$huh - 1}]]
       set outguess "$pref$suff"
     } 



     set huh [ourstringlast "$ourguess!" "%3F!" 0]
     if { [expr {($huh)}] > 0 } {
       set suff "@"
       set pref [string range "$ourguess" 0 [expr {$huh - 1}]]
       set outguess "$pref$suff"
     } else {
       set lastchar [string range "$ourguess" [expr {[string length "$ourguess"] - 1}]  [expr {[string length "$ourguess"] - 1}]]
       set ischar $varr([eval {squareIs $sorder($ourword) $ourword}])
       if { "$ischar" != "$lastchar" } {
         set huh [expr {[string length "$ourguess"] - 1}] 
         set suff "@"
         set pref [string range "$ourguess" 0 [expr {$huh - 1}]]
         set outguess "$pref$suff"
       }
     }

      
     set huh [ourstringfirst "$outguess!" "%3F%3F%3F%3F%3F%3F%3F" 0]
     if { "$huh" == "0" } {
       set pref "%3F%3F"
       set midbit "@%3F@%3F@"
       set suff [string range "$outguess" 21 1000]
       set outguess "$pref$midbit$suff"
     } else {
     set huh [ourstringfirst "$outguess!" "%3F%3F%3F%3F%3F%3F" 0]
     if { "$huh" == "1" } {
       set pref [string range "$outguess" 0 0]
       set midbit "%3F@%3F@%3F@"
       set suff [string range "$outguess" 19 1000]
       set outguess "$pref$midbit$suff"
     } else {
     set huh [ourstringfirst "$outguess!" "%3F%3F%3F%3F%3F" 0]
     if { "$huh" == "2" } {
       set pref [string range "$outguess" 0 1]
       set midbit "@%3F@%3F@"
       set suff [string range "$outguess" 17 1000]
       set outguess "$pref$midbit$suff"
     } else {
     
     set huh [ourstringfirst "$outguess!" "**%3F%3F%3F%3F%3F" 0]
     if { "$huh" == "1" } {
       set pref [string range "$outguess" 0 0]
       set midbit "**%3F@%3F@%3F@"
       set suff [string range "$outguess" 21 1000]
       set outguess "$pref$midbit$suff"
     } else {
     set huh [ourstringfirst "$outguess!" "**%3F%3F%3F%3F%3F" 0]
     if { "$huh" == "2" } {
       set pref [string range "$outguess" 0 1]
       set midbit "**@%3F@%3F@"
       set suff [string range "$outguess" 19 1000]
       set outguess "$pref$midbit$suff"


}
     
     }
     }
     }
     }




   } else {
   if { "$ourda" == "12A" } {
     set huh [ourstringlast "$ourguess!" "%3F!" 0]
     if { [expr {($huh)}] > 0 } {
       set suff "@"
       set pref [string range "$ourguess" 0 [expr {$huh - 1}]]
       set outguess "$pref$suff"
     } else {
       set lastchar [string range "$ourguess" [expr {[string length "$ourguess"] - 1}]  [expr {[string length "$ourguess"] - 1}]]
       set ischar $varr([eval {squareIs $sorder($ourword) $ourword}])
       if { "$ischar" != "$lastchar" } {
         set huh [expr {[string length "$ourguess"] - 1}] 
         set suff "@"
         set pref [string range "$ourguess" 0 [expr {$huh - 1}]]
         set outguess "$pref$suff"
       }
     }

   } else {
   if { "$ourda" == "14A" } {
     set huh [ourstringlast "$ourguess!" "%3F!" 0]
     if { [expr {($huh)}] > 0 } {
       set suff "@"
       set pref [string range "$ourguess" 0 [expr {$huh - 1}]]
       set outguess "$pref$suff"
     } else {
       set lastchar [string range "$ourguess" [expr {[string length "$ourguess"] - 1}]  [expr {[string length "$ourguess"] - 1}]]
       set ischar $varr([eval {squareIs $sorder($ourword) $ourword}])
       if { "$ischar" != "$lastchar" } {
         set huh [expr {[string length "$ourguess"] - 1}] 
         set suff "@"
         set pref [string range "$ourguess" 0 [expr {$huh - 1}]]
         set outguess "$pref$suff"
       }
     }

   } else {
   if { "$ourda" == "15D" } {
     set huh [ourstringfirst "$outguess!" "%3F%3F%3F" 0]
     if { "$huh" == "0" } {
       set pref "%3F%3F"
       set midbit "@"
       set suff [string range "$outguess" 9 1000]
       set outguess "$pref$midbit$suff"
     } else {
     set huh [ourstringfirst "$outguess!" "%3F%3F" 0]
     if { "$huh" == "1" } {
       set pref [string range "$outguess" 0 0]
       set midbit "%3F@"
       set suff [string range "$outguess" 7 1000]
       set outguess "$pref$midbit$suff"
     } else {
     set huh [ourstringfirst "$outguess!" "%3F" 0]
     if { "$huh" == "2" } {
       set pref [string range "$outguess" 0 1]
       set midbit "@"
       set suff [string range "$outguess" 5 1000]
       set outguess "$pref$midbit$suff"
     } else {
     
     set huh [ourstringfirst "$outguess!" "**%3F" 0]
     if { "$huh" == "1" } {
       set pref [string range "$outguess" 0 0]
       set midbit "**%3F@"
       set suff [string range "$outguess" 9 1000]
       set outguess "$pref$midbit$suff"
     } else {
     set huh [ourstringfirst "$outguess!" "**%3F" 0]
     if { "$huh" == "2" } {
       set pref [string range "$outguess" 0 1]
       set midbit "**@"
       set suff [string range "$outguess" 7 1000]
       set outguess "$pref$midbit$suff"


}
     
     }
     }
     }
     }

   } else {
   if { "$ourda" == "29A" } {
     set huh [ourstringlast "$outguess!" "%3F%3F%3F%3F%3F%3F%3F!" 0]
     if { [expr {($huh)}] > 0 } {
       set pref [string range "$outguess" 0 [expr {$huh - 1}]]
       set midbit "@"
       set suff "%3F%3F%3F%3F%3F%3F"
       set outguess "$pref$midbit$suff"
     } 
    
     set huh [ourstringfirst "$outguess!" "%3F%3F%3F" 0]
     if { "$huh" == "0" } {
       set pref "%3F%3F"
       set midbit "@"
       set suff [string range "$outguess" 9 1000]
       set outguess "$pref$midbit$suff"
     } else {
     set huh [ourstringfirst "$outguess!" "%3F%3F" 0]
     if { "$huh" == "1" } {
       set pref [string range "$outguess" 0 0]
       set midbit "%3F@"
       set suff [string range "$outguess" 7 1000]
       set outguess "$pref$midbit$suff"
     } else {
     set huh [ourstringfirst "$outguess!" "%3F" 0]
     if { "$huh" == "2" } {
       set pref [string range "$outguess" 0 1]
       set midbit "@"
       set suff [string range "$outguess" 5 1000]
       set outguess "$pref$midbit$suff"
     } else {
     
     set huh [ourstringfirst "$outguess!" "**%3F" 0]
     if { "$huh" == "1" } {
       set pref [string range "$outguess" 0 0]
       set midbit "**%3F@"
       set suff [string range "$outguess" 9 1000]
       set outguess "$pref$midbit$suff"
     } else {
     set huh [ourstringfirst "$outguess!" "**%3F" 0]
     if { "$huh" == "2" } {
       set pref [string range "$outguess" 0 1]
       set midbit "**@"
       set suff [string range "$outguess" 7 1000]
       set outguess "$pref$midbit$suff"


}
     
     }
     }
     }
     }


   } else {
     set outguess "$outguess"
   }
   }
   }
   }
   }
   }
   }
   }
   }
   return "$outguess"
}

proc categorizeword {aword} {
  global sorder worder fourlist fournum fivelist fivenum sixlist sixnum sevenlist sevennum eightlist eightnum ninelist ninenum fifteenlist fifteennum
  set cnt [string length "$aword"]
      foreach xq "aA eE iI oO uU yY bB cC dD fF gG hH jJ kK lL mM nN pP qQ rR sS tT vV wW xX zZ" {
		set hhh [ourstringfirst $aword [string range $xq 0 0] 0]
		if { [expr {($hhh)}] >= 0 } {
		  while { [expr {($hhh)}] >= 0 } {
		set aword [string replace $aword $hhh $hhh [string range $xq 1 1]]
		set hhh [ourstringfirst $aword [string range $xq 0 0] 0]
		  }
		  }
		  }

if { [string range "$aword" [expr {$cnt - 1}] [expr {$cnt - 1}]] == "+" } {
set cnt [expr {$cnt - 1}]
}
if { [string range "$aword" [expr {$cnt - 1}] [expr {$cnt - 1}]] == " " } {
set cnt [expr {$cnt - 1}]
}

for {set i 0} {$i < $cnt} {set i [expr $i+1]} {
  if { [string range $aword $i $i] == " " || [string range $aword $i $i] == "+" } {
    set cnt 0
 #   puts "bad"
  }
}

    if { [expr {$cnt}] == 15 } {
    set fifteennum [expr {$fifteennum + 1}]
    set fifteenlist($fifteennum) [string range "$aword" 0 [expr {$cnt - 1}]]
   # puts "fifteenlist($fifteennum)=$fifteenlist($fifteennum)"
    } else {
    if { [expr {$cnt}] == 9 } {
    set ninenum [expr {$ninenum + 1}]
    set ninelist($ninenum) [string range "$aword" 0 [expr {$cnt - 1}]]
    } else {
    if { [expr {$cnt}] == 8 } {
    set eightnum [expr {$eightnum + 1}]
    set eightlist($eightnum) [string range "$aword" 0 [expr {$cnt - 1}]]
    } else {
    if { [expr {$cnt}] == 7 } {
    set sevennum [expr {$sevennum + 1}]
    set sevenlist($sevennum) [string range "$aword" 0 [expr {$cnt - 1}]]
    } else {
    if { [expr {$cnt}] == 6 } {
    set sixnum [expr {$sixnum + 1}]
    set sixlist($sixnum) [string range "$aword" 0 [expr {$cnt - 1}]]
    } else {
    if { [expr {$cnt}] == 5 } {
    set fivenum [expr {$fivenum + 1}]
    set fivelist($fivenum) [string range "$aword" 0 [expr {$cnt - 1}]]
 #   puts "fivelist($fivenum)=$fivelist($fivenum)"
    } else {
    if { [expr {$cnt}] == 4 } {
    set fournum [expr {$fournum + 1}]
    set fourlist($fournum) [string range "$aword" 0 [expr {$cnt - 1}]]
    }
    }
    }
    }
    }
    }
    }

}

set efours "SAND TRAM OBOE ROBE SCAN MACE EDAM FADE MEAT LIED IFFY SAFE UGLY HUGE SHAM ACHE TIME TRIM  "
set efours "$efours AJAR HAJJ SKIM LAKE SLUM FULL SMUT SAME SNUG SANE TOME ROOT SPAT HOPE AQUA IRAQ TRIP DART TSAR PAST STUN WITH SUMP TOUT EVER SAVE SWAT NEWT EXAM TAXI EYES WAYS IZZY FAZE"
set efives ""
set esixs ""
set esevens ""
set eeights ""
set enines ""
set efifteens ""

proc populatelist {} {
global efours efives esixs esevens eeights enines efifteens
     set url "http://poets.notredame.ac.jp/Roget/contents.html"
#puts $url
     #set filename [file tail $url]
     #set r [http::geturl $url -binary 1]
        if {[catch {set r [http::geturl $url -binary 1]} err]} { return $err }
#puts $oursuffix
# set url [lindex $argv 0]
# set filename [file tail $url]
# set r [http::geturl $url -binary 1]
# set fo [open $filename w]
# fconfigure $fo -translation binary
# puts -nonewline $fo [http::data $r]
# close $fo
# ::http::cleanup $r
# puts "Got $url -> $filename"


#set html [http::data $r]
        if {[catch {set html [http::data $r]} err]} { set html " " }
             foreach xxwr [split $html "><"] {
              set htmlnum "0"
              set thisword ""
		      foreach xwr [split $xxwr "()"] {
		       if { "$xwr" != "" } {
		       set htmlnum "$xwr"
		       if { "$htmlnum" >= "1" && "$htmlnum" <= "99999999999999" } {
		       set htmlnum "$xwr"
		       } else {
		         set thisword "$htmlnum"
		       }
		       }
		      }
		      if { "$htmlnum" >= "1" && "$htmlnum" <= "99999999999999" && "$thisword" != "" } {
		        # puts "categorze thisword=$thisword"
               categorizeword "$thisword"		       
		      }
             }
             
  foreach xx "q $efours" {
    categorizeword "$xx"		       
  }
             
  foreach xx "q $efives" {
    categorizeword "$xx"		       
  }
             
  foreach xx "q $esixs" {
    categorizeword "$xx"		       
  }
             
  foreach xx "q $esevens" {
    categorizeword "$xx"		       
  }
             
  foreach xx "q $eeights" {
    categorizeword "$xx"		       
  }
             
  foreach xx "q $enines" {
    categorizeword "$xx"		       
  }
             
  foreach xx "q $efifteens" {
    categorizeword "$xx"		       
  }
        
}

proc redostuff {} {
  global maps numthings valoks aorder worder corder oorder sorder xorder morder ourorder oourorder sourorder
global sqsize mode barr xarr marr xarr yarr zarr
if { 1 == 1 } {


for {set ii 0} {$ii < $mode} {set ii [expr $ii+1]} {
  set barr([expr {$ii + 1}]) 0
  set varr([expr {$ii + 1}]) " "
  set arr([expr {$ii + 1}]) " "
  set marr([expr {$ii + 1}]) ""
  set xarr([expr {$ii + 1}]) ""
  set yarr([expr {$ii + 1}]) ""
  set zarr([expr {$ii + 1}]) ""
  set valoks([expr {$ii + 1}]) ""
}

  set spare(1) ""
  for {set iij 1} {$iij <= $numthings} {set iij [expr $iij+1]} { 
   set spare($iij) $valoks($maps($iij))
  }
  for {set iij 1} {$iij <= $numthings} {set iij [expr $iij+1]} { 
   set valoks($iij) $spare($iij)
  }
  for {set iij 1} {$iij <= $numthings} {set iij [expr $iij+1]} { 
   set spare($iij) $aorder($maps($iij))
  }
  for {set iij 1} {$iij <= $numthings} {set iij [expr $iij+1]} { 
   set aorder($iij) $spare($iij)
  }
  for {set iij 1} {$iij <= $numthings} {set iij [expr $iij+1]} { 
   set spare($iij) $worder($maps($iij))
  }
  for {set iij 1} {$iij <= $numthings} {set iij [expr $iij+1]} { 
   set worder($iij) $spare($iij)
  }
  for {set iij 1} {$iij <= $numthings} {set iij [expr $iij+1]} { 
   set spare($iij) $corder($maps($iij))
  }
  for {set iij 1} {$iij <= $numthings} {set iij [expr $iij+1]} { 
   set corder($iij) $spare($iij)
  }
  for {set iij 1} {$iij <= $numthings} {set iij [expr $iij+1]} { 
   set spare($iij) $oorder($maps($iij))
  }
  for {set iij 1} {$iij <= $numthings} {set iij [expr $iij+1]} { 
   set oorder($iij) $spare($iij)
  }
  for {set iij 1} {$iij <= $numthings} {set iij [expr $iij+1]} { 
   set spare($iij) $sorder($maps($iij))
  }
  for {set iij 1} {$iij <= $numthings} {set iij [expr $iij+1]} { 
   set sorder($iij) $spare($iij)
  }
  for {set iij 1} {$iij <= $numthings} {set iij [expr $iij+1]} { 
   set spare($iij) $xorder($maps($iij))
  }
  for {set iij 1} {$iij <= $numthings} {set iij [expr $iij+1]} { 
   set xorder($iij) $spare($iij)
  }
  for {set iij 1} {$iij <= $numthings} {set iij [expr $iij+1]} { 
   set spare($iij) $morder($maps($iij))
  }
  for {set iij 1} {$iij <= $numthings} {set iij [expr $iij+1]} { 
   set morder($iij) $spare($iij)
   #puts "$xorder($iij) $sorder($iij) $corder($iij) $worder($iij) $oorder($iij) $morder($iij) $aorder($iij) $valoks($iij) "
  }
  
set ourorder "$xorder(1) $xorder(2) $xorder(3) $xorder(4) $xorder(5) $xorder(6) $xorder(7) $xorder(8) $xorder(9) $xorder(10) $xorder(11) $xorder(12) $xorder(13) $xorder(14) $xorder(15) $xorder(16) $xorder(17) $xorder(18) $xorder(19) $xorder(20) $xorder(21) $xorder(22) $xorder(23) $xorder(24) $xorder(25) $xorder(26) $xorder(27) $xorder(28) $xorder(29) $xorder(30)"
set oourorder "$oorder(1) $oorder(2) $oorder(3) $oorder(4) $oorder(5) $oorder(6) $oorder(7) $oorder(8) $oorder(9) $oorder(10) $oorder(11) $oorder(12) $oorder(13) $oorder(14) $oorder(15) $oorder(16) $oorder(17) $oorder(18) $oorder(19) $oorder(20) $oorder(21) $oorder(22) $oorder(23) $oorder(24) $oorder(25) $oorder(26) $oorder(27) $oorder(28) $oorder(29) $oorder(30)"
set sourorder "$sorder(1) $sorder(2) $sorder(3) $sorder(4) $sorder(5) $sorder(6) $sorder(7) $sorder(8) $sorder(9) $sorder(10) $sorder(11) $sorder(12) $sorder(13) $sorder(14) $sorder(15) $sorder(16) $sorder(17) $sorder(18) $sorder(19) $sorder(20) $sorder(21) $sorder(22) $sorder(23) $sorder(24) $sorder(25) $sorder(26) $sorder(27) $sorder(28) $sorder(29) $sorder(30)"
for {set ii 0} {$ii < $mode} {set ii [expr $ii+1]} {
  set jkl 0
  foreach xxhuh "$oourorder" {
    set jkl [expr {$jkl + 1}]
    if { $xxhuh == [expr {$ii + 1}] } {
      set iy 0
      if { $morder([expr {$jkl}]) == "D" } {
        for {set iii $oorder([expr {$jkl}])} {$iii < ([expr {$oorder([expr {$jkl}]) + $sorder([expr {$jkl}]) * $sqsize}])} {set iii [expr $iii+$sqsize]} {
         set iy [expr {$iy + 1}]
         set barr([expr {$iii}]) 1
         set xarr([expr {$iii}]) "$xarr([expr {$iii}]) $xorder([expr {$jkl}])"
         set marr([expr {$iii}]) "$marr([expr {$iii}]) $morder([expr {$jkl}])"
         set yarr([expr {$iii}]) "$yarr([expr {$iii}]) $iy"
         set zarr([expr {$iii}]) "$zarr([expr {$iii}]) [expr {$jkl}]"
         
  #       puts "square $iii has zarr($iii)=$zarr($iii)  yarr($iii)=$yarr($iii)"
        }
      } else {
        for {set iii $oorder([expr {$jkl}])} {$iii < ([expr {$oorder([expr {$jkl}]) + $sorder([expr {$jkl}])}])} {set iii [expr $iii+1]} {
         set iy [expr {$iy + 1}]
         set barr([expr {$iii}]) 1
         set xarr([expr {$iii}]) "$xarr([expr {$iii}]) $xorder([expr {$jkl}])"
         set marr([expr {$iii}]) "$marr([expr {$iii}]) $morder([expr {$jkl}])"
         set yarr([expr {$iii}]) "$yarr([expr {$iii}]) $iy"
         set zarr([expr {$iii}]) "$zarr([expr {$iii}]) [expr {$jkl}]"
         
         #puts "yarr([expr {$iii}])=$yarr([expr {$iii}]) zarr([expr {$iii}])=$zarr([expr {$iii}])"
         
 #        puts "Square $iii has zarr($iii)=$zarr($iii)  yarr($iii)=$yarr($iii)"
        }
      }
    }
  }
}

}

  for {set iij 1} {$iij <= $numthings} {set iij [expr $iij+1]} { 
   set maps($iij) $iij
  }



}


set uninteresting "2 4 6 8 10 12 14 32 34 36 38 40 42 44 53 61 63 64 66 68 70 72 74 85 91 93 94 96 97 98 100 101 102 104 113 122 124 125 126 128 129 130 132 133 135 141 152 154 156 158 160 162 163 165 173 182 184 186 188 190 192 194 212 214 216 218 220 222 224"

proc inventAllWords {} {
  global phraseTry phraseBigTry maps prenono sqsize mode xc numthings worder corder barr zarr xarr marr yarr varr arr oorder sorder oourorder sourorder xorder morder
  global fourlist fournum fivelist fivenum sixlist sixnum sevenlist sevennum eightlist eightnum ninelist ninenum fifteenlist fifteennum
  global desperateword  desperatecount desperatebackup
  global desperatecontents desperatereveal percent
  global desperateclue desperaterating pb cone

  global hone pone zone jone w difficulty uninteresting

  redostuff
  
  puts " "
  puts "Crossword clues ($numthings) will appear below ..."
  puts " "

  ttk::button $w.buttons.value -text "Value" 
  
  ttk::combobox $w.buttons.ourvalue -textvariable squareval -width 8 -values [list Letter A B C D E F G H I J K L M N O P Q R S T U V W X Y Z]
  pack $w.buttons.value -side left -padx 5 -pady 6 
  pack $w.buttons.ourvalue -side left -padx 20

	
  set percent 0
  set pb [ttk::progressbar .pb1 -mode determinate -length 800 -orient horizontal -maximum 100 -value 0 -variable percent]
  pack .pb1 -side bottom -fill x

  frame $w.frame -width 720 -height 528 -borderwidth 2 -relief sunken -bg red    
  pack $w.frame -side top -pady 1c -padx 1c
  focus -force $w
  tk_focusFollowsMouse


set xpos(1) 0
set ypos(1) 0


for {set i 0} {$i < $mode} {set i [expr $i+1]} {
    set cone([expr {$i + 1}]) ""
#set num [lindex $order $i]
set num [expr {$i + 1}]
#puts "num=$num"
#puts "varr($num)=$varr($num)"
##set arr([expr {$i + 1}]) "$num"
   set row [expr {($i) / $sqsize}]
   set col [expr {($i) % $sqsize}]

set xpos($num) [expr ($i % $sqsize)*(1.0 / $sqsize)]
set ypos($num) [expr ($i / $sqsize)*(1.0 / $sqsize)]
#puts "i=$i num=$num varr([expr {$i + 1}]))=$varr([expr {$i + 1}]) arr([expr {$i + 1}]))=$arr([expr {$i + 1}]) cone([expr {$i + 1}]))=$cone([expr {$i + 1}])"

set isinteresting 1
foreach kjh "$uninteresting" {
  if { [expr {$i + 1}] == $kjh } {
    set isinteresting 0
  }
}


if { "$isinteresting" == "0" } {
button $w.frame.[expr {$i + 1}] -state disabled -bg black -relief sunken -textvariable arr([expr {$i + 1}]) -highlightthickness 0 -command "Crossword $mode [expr {$i + 1}]"
place $w.frame.[expr {$i + 1}] -relx $xpos($num) -rely $ypos($num) -relwidth [expr {1.0 / $sqsize}] -relheight [expr {1.0 / $sqsize}]  -height $hone([expr {$i + 1}]) -width $jone([expr {$i + 1}])
} else {

for {set ii 1} {$ii <= $numthings} {set ii [expr $ii+1]} {
  if { [expr {$i + 1}] == $oorder($ii) } {
    set xxqq [ourstringlast $xorder([expr {$ii}]) $morder([expr {$ii}]) 0]
    set arr([expr {$i + 1}]) [string range $xorder([expr {$ii}]) 0 [expr {$xxqq - 1}]]
    set cone([expr {$i + 1}]) [string range $xorder([expr {$ii}]) 0 [expr {$xxqq - 1}]]
  }
}


button $w.frame.[expr {$i + 1}] -relief raised -bg white -textvariable arr([expr {$i + 1}]) -highlightthickness 0 -command "Crossword $mode [expr {$i + 1}]"
place $w.frame.[expr {$i + 1}] -relx $xpos($num) -rely $ypos($num) -relwidth [expr {1.0 / $sqsize}]  -relheight [expr {1.0 / $sqsize}]  -height $hone([expr {$i + 1}]) -width $jone([expr {$i + 1}])
}


}



  ##strategics
  strategics2
  for {set iij 1} {$iij <= $numthings} {set iij [expr $iij+1]} { 
	$pb start
   set percent [expr {round((((($iij - 1) * 100) /  $numthings) + 1))}]
	$pb stop
    if { 67 == 78 && "$worder($maps($iij))" < "                    " && [expr {$sorder($maps($iij))}] == 15 } { 
     #puts "worder($maps($iij))=$worder($maps($iij))"
     set ok "n"
     
     set desperateword $maps($iij)
     set desperatecontents ""
     set desperateclue ""
     set desperatecount 0
     set desperatereveal "n"
     set desperaterating 0
     set desperatebackup ""
     
     set zLen $sorder($maps($iij))
     
     while { "$ok" == "n" } {
     
      while { "$fifteennum" == "0" } {
        populatelist
      }
      
      while { "$worder($maps($iij))" < "                    " } {  
        pickoneout $maps($iij)
        #set zLen [string length $worder($maps($iij))]
      }
     
      set guess ""
      set altguess ""
      set prevLetter "e"
      
      for {set iik 1} {$iik <= $zLen} {set iik [expr $iik+1]} {
      set theLetter [string range "$worder($maps($iij))" [expr {$iik - 1}] [expr {$iik - 1}]]
      set nextLetter [string range "$worder($maps($iij)) " [expr {$iik}] [expr {$iik}]]
      if { "$theLetter" == "" } {
      set theLetter " "
      }
      if { "$nextLetter" == " " } {
      set nextLetter "e"
      }
      
      if { "$theLetter" != " "  && "$theLetter" != "" } {
      set guess "$guess$theLetter"
      set altguess "$altguess$theLetter"
      set prevLetter "$theLetter"
      } else {
      if { [expr {1+round(rand()*1)}] == 1 } {
       set pok 0
       while { $pok == 0 } {
       set chone [expr {65+round(rand()*25)}]   
       set pok 1
       
       set relevant 1
       set sc ";"
       if { [string length "$guess      "] <= 1 } {
		 set sc ""        
       }
       
       foreach bhg $prenono("$nextLetter") {
       if { "$bhg" == "$sc" } {
       set relevant 0
       }
       if { "$relevant" != "0" } {
       if { "$bhg" == "$xc($chone)" } {
       set pok 0
       }
       }
       }

       
       foreach bhg $prenono("[eval {giveBackLetter $maps($iij) $iik 0}]") {
       if { "$bhg" == "$sc" } {
       set relevant 0
       }
       if { "$relevant" != "0" } {
       if { "$bhg" == "$xc($chone)" } {
       set pok 0
       }
       }
       }
       
       set relevant 1
       set sc ";"
       if { [string length "$guess"] <= 1 } {
		 set sc ""        
       }
       
       
       foreach bhg $prenono("$xc($chone)") {
       if { "$bhg" == "$sc" } {
       set relevant 0
       }
       if { "$relevant" != "0" } {
       if { "$bhg" == "$prevLetter" } {
       set pok 0
       }
       }
       }
       
       
       foreach bhg $prenono("[eval {giveBackLetter $maps($iij) $iik 0}]") {
       if { "$bhg" == "$sc" } {
       set relevant 0
       }
       if { "$relevant" != "0" } {
       if { "$bhg" == "$prevLetter" } {
       set pok 0
       }
       }
       }
       
       
       #if { "$squ" >= "196" && ("$xc([expr {$chone}])" == "Q" || "$xc([expr {$chone}])" == "J") } {
	#	set pok 0
     #  }
       
       }
       
       set guess "$guess$xc($chone)"
       set altguess "$altguess$xc($chone)"
       set prevLetter "$xc($chone)"
      } else {
       set guess "$guess%3F"
       set theLetter "+"
       set altguess "$altguess$theLetter"
       set prevLetter "e"
      }
      }
      }
      
      
      
      set cWord ""
      if { "$cWord" == "" } {
      #puts "guess=$guess for word $maps($iij)"
      set guess [eval {extraIntelligence $guess $maps($iij) $sorder($maps($iij)) $xorder($maps($iij))}]
        set cWord [eval {inventWord $guess $maps($iij) $sorder($maps($iij)) $altguess 0}]
      #puts "cWord=$cWord"
      }

      set ok [eval {checkWord "$cWord" $sorder($maps($iij)) 1}]
      
      if { "$ok" == " " } {
        set cWord "$worder($maps($iij))"
      }
      
      if { "$ok" != "n" && "$ok" != " " } {
        set corder($maps($iij)) "$corder($maps($iij)) ($ok)"
       # puts "corder($maps($iij))=$corder($maps($iij)) morder($maps($iij))=$morder($maps($iij)) "


       if { "$morder([expr {$maps($iij)}])" == "D" } {
        set ourpos 0
        for {set iii $oorder([expr {$maps($iij)}])} {$iii < ([expr {$oorder([expr {$maps($iij)}]) + $sorder([expr {$maps($iij)}]) * $sqsize}])} {set iii [expr $iii+$sqsize]} {

         set iind 0
         
         set ourpos [expr {$ourpos + 1}]
         
         if { "$zarr([eval {squareIs $ourpos $maps($iij)}])" == "" } {
         
              set cwl [eval {checkWordLetter "$cWord" $sorder($maps($iij)) $ourpos}]
              set varr($iii) $cwl
         } else {

              set cwl [eval {checkWordLetter "$cWord" $sorder($maps($iij)) $ourpos}]
              setWorder $maps($iij) $ourpos $cwl $iii

         
         #foreach qw "$zarr($maps($iij))" {
          # set iind [expr {$iind + 1}]
           #set ourpos 0
           #set jind 0
           #foreach qqw "$yarr($maps($iij))" {
            #set jind [expr {$jind + 1}]
            #if { "$jind" == "$iind" } {
             # set ourpos $qqw
              #set cwl [eval {checkWordLetter "$cWord" $sorder($maps($iij)) [expr {$iii - $oorder([expr {$maps($iij)}]) + 1}]}]
              #setWorder $qw $ourpos $cwl $iii
            #}
           #}
         
         #}
         }

        }
       } else {
        set ourpos 0
        for {set iii $oorder([expr {$maps($iij)}])} {$iii < ([expr {$oorder([expr {$maps($iij)}]) + $sorder([expr {$maps($iij)}])}])} {set iii [expr $iii+1]} {

         set iind 0
         set ourpos [expr {$ourpos + 1}]
         
         if { "$zarr($iii)" == "" } {
         #puts "here for $maps($iij) ..."
              set cwl [eval {checkWordLetter "$cWord" $sorder($maps($iij)) $ourpos}]
              set varr($iii) $cwl
         } else {
         #puts "vs here for $maps($iij) ..."
              set cwl [eval {checkWordLetter "$cWord" $sorder($maps($iij)) $ourpos}]
              setWorder $maps($iij) $ourpos $cwl $iii
         #foreach qw "$zarr($maps($iij))" {
         #  set iind [expr {$iind + 1}]
         #  set ourpos 0
         #  set jind 0
         #  foreach qqw "$yarr($maps($iij))" {
          #  set jind [expr {$jind + 1}]
           # if { "$jind" == "$iind" } {
           #   set ourpos $qqw
            #  set cwl [eval {checkWordLetter "$cWord" $sorder($maps($iij)) [expr {$iii - $oorder([expr {$maps($iij)}]) + 1}]}]
            #  setWorder $qw $ourpos $cwl $iii
            #}
           #}
         
         #}
         }

        }
        }
       }


      
      
     }



    } else { 
    
     
     set desperateword $maps($iij)
     set desperatecontents ""
     set desperateclue ""
     set desperatecount 0
     set desperatereveal "n"
     set desperaterating 0
     set desperatebackup ""
     
     set lastguess ""
     set twentyfive 25
     set ok "n"
     while { "$ok" == "n" } {
      set zLen $sorder($maps($iij))
      set guess ""
      set altguess ""
      set block 0
      set prevLetter "e"

      set phraseTry ""
      set phraseBigTry ""

      set firstBad ""
      
      for {set iik 1} {$iik <= $zLen} {set iik [expr $iik+1]} {
      set theLetter [string range "$worder($maps($iij))" [expr {$iik - 1}] [expr {$iik - 1}]]
      set nextLetter [string range "$worder($maps($iij)) " [expr {$iik}] [expr {$iik}]]
      if { "$theLetter" == "" } {
      set theLetter " "
      }
      if { "$nextLetter" == " " } {
      set nextLetter "e"
      }
      
      if { [expr {$sorder($maps($iij))}] != 15  } {
      set twentyfive 25
      }
      
      if { "$theLetter" != " "  && "$theLetter" != "" } {
      set guess "$guess$theLetter"
      set altguess "$altguess$theLetter"
      #puts "gGuess=$guess"
      set block [eval {isNextSquareNotControversial [expr {$iik + 1}] $maps($iij)}]
        if { $iik == 1 } {
          set phraseTry [eval {asterTwo "$guess" $maps($iij) 0}]
        }
      } else {
      if { ([expr {$sorder($maps($iij))}] == 9915 && $iik == 1) || $iik == 1 } {
       set pok 0
       while { $pok == 0 } {
       set chone [expr {65+round(rand()*25)}] 
       
       #if { "$xorder($maps($iij))" == "1D" } {
        # puts "chone=$xc($chone)"
       #}
       
       set pok 1
       foreach bhg $prenono("$nextLetter") {
       if { "$bhg" == "$xc($chone)" } {
       if { "$firstBad" == "" } {
         set firstBad "$xc($chone)"
       #if { "$xorder($maps($iij))" == "1D" } {
        # puts "firstBad1=$firstBad"
       #}
       }
       #if { "$xorder($maps($iij))" == "1D" } {
        # puts "reject RE nextLetter=$nextLetter prenono=$prenono(\"$nextLetter\") bhg=$bhg"
       #}
       set pok 0
       }
       }

       
       foreach bhg $prenono("[eval {giveBackLetter $maps($iij) $iik 0}]") {
       if { "$bhg" == "$xc($chone)" } {
       if { "$firstBad" == "" } {
         set firstBad "$xc($chone)"
       #if { "$xorder($maps($iij))" == "1D" } {
        # puts "firstBad2=$firstBad"
       #}
       }
       #if { "$xorder($maps($iij))" == "1D" } {
        # puts "reject RE thingo=[eval {giveBackLetter $maps($iij) $iik 0}] prenono=$prenono(\"[eval {giveBackLetter $maps($iij) $iik 0}]\") bhg=$bhg"
       #}
       set pok 0
       }
       }

       foreach bhg $prenono("$xc($chone)") {
       if { "$bhg" == "$prevLetter" } {
       if { "$firstBad" == "" } {
         set firstBad "$xc($chone)"
       #if { "$xorder($maps($iij))" == "1D" } {
       #  puts "firstBad3=$firstBad"
       #}
       }
       #if { "$xorder($maps($iij))" == "1D" } {
       #  puts "reject RE this=$xc($chone) prenono=$prenono(\"$xc($chone)\") bhg=$bhg"
       #}
       set pok 0
       }
       }
       }
       
       foreach bhg $prenono("[eval {giveBackLetter $maps($iij) $iik 1}]") {
       if { "$bhg" == "$xc($chone)" } {
       if { "$firstBad" == "" } {
         set firstBad "$xc($chone)"
       #if { "$xorder($maps($iij))" == "1D" } {
       #  puts "firstBad4=$firstBad"
       #}
       }
       #if { "$xorder($maps($iij))" == "1D" } {
       #  puts "reject RE Thingo=[eval {giveBackLetter $maps($iij) $iik 1}] prenono=$prenono(\"[eval {giveBackLetter $maps($iij) $iik 1}]\") bhg=$bhg"
       #}
       set pok 0
       }
       }

       set guess "$guess$xc($chone)"
      #puts "ggGuess=$guess"
       set altguess "$altguess$xc($chone)"
       set block  [eval {isNextSquareNotControversial [expr {$iik + 1}] $maps($iij)}]
        if { $iik == 1 } {
          set phraseTry [eval {asterTwo "$guess" $maps($iij) 1}]
        }
      } else {
      if { [expr {1+round(rand()*1)}] == 1 && [expr {$sorder($maps($iij))}] != 15 && $block == 0 } {
       set pok 0
       while { $pok == 0 } {
       set chone [expr {65+round(rand()*25)}]   
       #if { "$xorder($maps($iij))" == "1D" } {
       #  puts "Chone=$xc($chone)"
       #}
       set pok 1
       
       set relevant 1
       set sc ";"
       if { [string length "$guess       "] <= 1 } {
		 set sc ""        
       }
       
       if { "$nextLetter" == " " || "$nextLetter" == "" } {
         set nextLetter "e"
       }
       
       foreach bhg $prenono("$nextLetter") {
       if { "$bhg" == "$sc" } {
       set relevant 0
       }
       if { "$relevant" != "0" } {
       if { "$bhg" == "$xc($chone)" } {
       if { "$firstBad" == "" } {
         set firstBad "$xc($chone)"
       #if { "$xorder($maps($iij))" == "1D" } {
       #  puts "firstBad5=$firstBad"
       #}
       }
       #if { "$xorder($maps($iij))" == "1D" } {
       #  puts "Reject RE nextLetter=$nextLetter prenono=$prenono(\"$nextLetter\") bhg=$bhg"
       #}
       set pok 0
       }
       }
       }

       
       set relevant 1
       set sc ";"
       if { [string length "$guess"] <= 1 } {
		 set sc ""        
       }
       
       
       foreach bhg $prenono("$xc($chone)") {
       if { "$bhg" == "$sc" } {
       set relevant 0
       }
       if { "$relevant" != "0" } {
       if { "$bhg" == "$prevLetter" } {
       if { "$firstBad" == "" } {
         set firstBad "$xc($chone)"
       #if { "$xorder($maps($iij))" == "1D" } {
       #  puts "firstBad6=$firstBad"
       #}
       }
       #if { "$xorder($maps($iij))" == "1D" } {
       #  puts "Reject RE this=$xc($chone) prenono=$prenono(\"$xc($chone)\") bhg=$bhg"
       #}
       set pok 0
       }
       }
       }
       
       #if { "$squ" >= "196" && ("$xc([expr {$chone}])" == "Q" || "$xc([expr {$chone}])" == "J") } {
	#	set pok 0
     #  }
       
       
       }
       
       set guess "$guess$xc($chone)"
      #puts "ggGuess=$guess"
       set altguess "$altguess$xc($chone)"
       set block [eval {isNextSquareNotControversial [expr {$iik + 1}] $maps($iij)}]
      } else {
       set guess "$guess%3F"
      #puts "gggGuess=$guess"
       set theLetter "+"
       set altguess "$altguess$theLetter"
       set block 0
      }
      }
      }
      }
      
      
      
      set cWord ""
      if { "$cWord" == "" } {
      if { "$guess" != "$lastguess" } {
      set guess [eval {extraIntelligence $guess $maps($iij) $sorder($maps($iij)) $xorder($maps($iij))}]
      set lastguess "$guess"
      #puts "Guess=$guess for word $maps($iij) $xorder($maps($iij)) of length $sorder($maps($iij))"

              set newah "%3F[string range $altguess 1 1000]"
              set newh "+[string range $guess 1 1000]"
              set qwtzz [eval {altaltinventWord $newh $maps($iij) $sorder($maps($iij)) $newah 1}]
              if { "$qwtzz" != "" && [expr {$desperaterating}] < 10 } {
                set desperatecontents "$qwtzz"
                set desperateword "$maps($iij)"
                set desperaterating 10
                set desperateclue "$corder($maps($iij))"
              }

      set cWord [eval {inventWord $guess $maps($iij) $sorder($maps($iij)) $altguess 0}]
      #puts "CWord=$cWord"
      } else {
       if { "$firstBad" != "" && [expr {$sorder($maps($iij))}] < 997 } {
         set guess [string range $guess 1 1000]
         set altguess [string range $altguess 1 1000]
         set guess "$firstBad$guess"
         set altguess "$firstBad$altguess"
          set phraseTry [eval {asterTwo "$firstBad" $maps($iij) 1}]
      set lastguess "$guess"
      set guess [eval {extraIntelligence $guess $maps($iij) $sorder($maps($iij)) $xorder($maps($iij))}]
      #puts "GuesS=$guess for word $maps($iij) $xorder($maps($iij)) of length $sorder($maps($iij))"
      set cWord [eval {inventWord $guess $maps($iij) $sorder($maps($iij)) $altguess 0}]
      #puts "CWorD=$cWord"
              if { "$cWord" != ""  && [expr {$desperaterating}] < 50 } {
                set desperatecontents "$cWord"
                set desperateword "$maps($iij)"
                set desperaterating 50
                set desperateclue "$corder($maps($iij))"
              }
       }
      }
      }

      set ok [eval {checkWord "$cWord" $sorder($maps($iij)) 2}]
      
      if { "$ok" == " " } {
        set cWord "$worder($maps($iij))"
      }
      
      if { "$ok" != "n" && "$ok" != " " } {
              if { "$cWord" != "" && [expr {$desperaterating}] < 100 } {
                set desperatecontents "$cWord"
                set desperateword "$maps($iij)"
                set desperaterating 100
                set desperateclue "$corder($maps($iij))"
              }
        #set corder($maps($iij)) "$corder($maps($iij)) ($ok)"

#puts "ok yes morder([expr {$maps($iij)}])=$morder([expr {$maps($iij)}])  oorder([expr {$maps($iij)}])=$oorder([expr {$maps($iij)}])  xorder([expr {$maps($iij)}])=$xorder([expr {$maps($iij)}])"

       if { "$morder([expr {$maps($iij)}])" == "D" } {
         set ourpos 0
        for {set iii $oorder([expr {$maps($iij)}])} {$iii < ([expr {$oorder([expr {$maps($iij)}]) + $sorder([expr {$maps($iij)}]) * $sqsize}])} {set iii [expr $iii+$sqsize]} {

         set iind 0
         set ourpos [expr {$ourpos + 1}]
         if { "$zarr($iii)" == "" } {
         
              set cwl [eval {checkWordLetter "$cWord" $sorder($maps($iij)) $ourpos}]
              set varr($iii) $cwl
         } else {
              set cwl [eval {checkWordLetter "$cWord" $sorder($maps($iij)) $ourpos}]
#puts "pre setWorder $cwl"
              setWorder $maps($iij) $ourpos $cwl $iii
#puts "post setWorder $worder($maps($iij))"
         #foreach qw "$zarr($maps($iij))" {
         #  set iind [expr {$iind + 1}]
         #  set ourpos 0
         #  set jind 0
         #  foreach qqw "$yarr($maps($iij))" {
          #  set jind [expr {$jind + 1}]
           # if { "$jind" == "$iind" } {
           #   set ourpos $qqw
            #  set cwl [eval {checkWordLetter "$cWord" $sorder($maps($iij)) [expr {$iii - $oorder([expr {$maps($iij)}]) + 1}]}]
            #  setWorder $qw $ourpos $cwl $iii
            #}
           #}
         
         #}
         }

        }
  
  for {set iiii 1} {$iiii <= $sqsize} {set iiii [expr $iiii+1]} {
  set cline ""
  for {set jjjj 1} {$jjjj <= $sqsize} {set jjjj [expr $jjjj+1]} {
  set cline "$cline$varr([expr {($iiii - 1) * $sqsize + $jjjj}])"
  }
  #puts $cline
  }


  for {set iiii 1} {$iiii <= $numthings} {set iiii [expr $iiii+1]} {
  if { "$desperateword" == "$maps($iiii)" } {
    #puts "$iiii CLUE $xorder($maps($iiii)) $corder($maps($iiii))"
    puts "Clue for $xorder($maps($iiii)) is ... $corder($maps($iiii))"
  #} else {
   # puts "$iiii Clue $xorder($maps($iiii)) $corder($maps($iiii))"
  }
  }  

       } else {
        set ourpos 0
        for {set iii $oorder([expr {$maps($iij)}])} {$iii < ([expr {$oorder([expr {$maps($iij)}]) + $sorder([expr {$maps($iij)}])}])} {set iii [expr $iii+1]} {

         set iind 0
         set ourpos [expr {$ourpos + 1}]
         if { "$zarr($iii)" == "" } {
         
              set cwl [eval {checkWordLetter "$cWord" $sorder($maps($iij)) $ourpos}]
              set varr($iii) $cwl
         } else {
              set cwl [eval {checkWordLetter "$cWord" $sorder($maps($iij)) $ourpos}]
#puts "Pre setWorder"
              setWorder $maps($iij) $ourpos $cwl $iii
#puts "Post setWorder"
         #foreach qw "$zarr($maps($iij))" {
         #  set iind [expr {$iind + 1}]
         #  set ourpos 0
         #  set jind 0
         #  foreach qqw "$yarr($maps($iij))" {
          #  set jind [expr {$jind + 1}]
           # if { "$jind" == "$iind" } {
           #   set ourpos $qqw
            #  set cwl [eval {checkWordLetter "$cWord" $sorder($maps($iij)) [expr {$iii - $oorder([expr {$maps($iij)}]) + 1}]}]
            #  setWorder $qw $ourpos $cwl $iii
            #}
           #}
         
         #}
         }

        }
         
  for {set iiii 1} {$iiii <= $sqsize} {set iiii [expr $iiii+1]} {
  set cline ""
  for {set jjjj 1} {$jjjj <= $sqsize} {set jjjj [expr $jjjj+1]} {
  set cline "$cline$varr([expr {($iiii - 1) * $sqsize + $jjjj}])"
  }
  #puts $cline
  }


  for {set iiii 1} {$iiii <= $numthings} {set iiii [expr $iiii+1]} {
  if { "$desperateword" == "$maps($iiii)" } {
    #puts "$iiii CLUE $xorder($maps($iiii)) $corder($maps($iiii))"
    puts "Clue for $xorder($maps($iiii)) is ... $corder($maps($iiii))"
  #} else {
    #puts "$iiii Clue $xorder($maps($iiii)) $corder($maps($iiii))"
  }
  }  
 
       }

       afterThisWordFixParticularSquares [expr {$maps($iij)}]
	$pb start
   set percent [expr {round(((($iij * 100) /  $numthings)))}]
	$pb stop
       #puts "here ... $percent for $iij"

      }
      
     }



    
    
    } 
  } 
     
  
  
  for {set iii 1} {$iii <= $sqsize} {set iii [expr $iii+1]} {
  set cline ""
  for {set jjj 1} {$jjj <= $sqsize} {set jjj [expr $jjj+1]} {
  set cline "$cline$varr([expr {($iii - 1) * $sqsize + $jjj}])"
  }
  #puts $cline
  }

  if { 1 == 2 } {
  for {set iii 1} {$iii <= $numthings} {set iii [expr $iii+1]} {
  if { "$desperateword" == "$maps($iii)" } {
    #puts "$iii CLUE $xorder($maps($iii)) $corder($maps($iii))"
    puts "Clue for $xorder($maps($iii)) is ... $corder($maps($iii))"
  #} else {
    #puts "$iii Clue $xorder($maps($iii)) $corder($maps($iii))"
  }
  }  
  }
  
     
	$pb start
   set percent 100
	$pb stop
  puts " "
  puts " ... clues done ... thanks for waiting ... over to you."
  puts " "
} 

proc getRidOfChevronStuff {stuff findLastThis} {

set outstuff "$stuff"

set ourfirst [ourstringfirst "$stuff" "$findLastThis" 0]
set ourlast [ourstringlast "$stuff" "$findLastThis" 0]
if { [expr {($ourlast)}] >= 0 } {
  if { "$ourlast" != "1" && ([string range "$findLastThis" 0 0] == ">" || [string range "$findLastThis" 0 0] == "<") } {
    set ourlast [expr {$ourlast - 1}]
  }
}




if { [expr {($ourlast)}] < 0 ||  [expr {[string length "$stuff"] - $ourlast}] } {
 set ourlastx [ourstringfirst "$stuff" " onmouseover" 0]
 if { [expr {($ourlastx)}] >= 0 } {
    set ourlast $ourlastx
 }
}

if { [expr {($ourlast)}] < 0  || [expr {[string length "$stuff"] - $ourlast}] } {
 set ourlasty [ourstringfirst "$stuff" " " 0]
 if { [expr {($ourlasty)}] >= 0 } {
    set ourlast $ourlasty
 }
}
 
if { [expr {($ourlast)}] >= 0 } {
if { [expr {($ourfirst)}] >= 0 } {
   if { [expr {[string length "$stuff"] - $ourlast}] < 40 } {
     set ourlast $ourfirst
   }
}  
  set outstuff " >"
  set valid 0
  
  set ctlfmi [ourstringfirst [string range "$stuff" $ourlast 1000] "Click the link for more information." 0]
  if { [expr {($ctlfmi)}] >= 0 } {
    set ourlast [expr {$ctlfmi + [string length "Click the link for more information. "]}]
  }
  
  
  for {set iii [expr {$ourlast - 1}]} {$iii < [string length "$stuff"]} {set iii [expr $iii+1]} {
    set thisc [string range "$stuff" $iii $iii]
    if { "$thisc" == ">" } {
      set valid 1
    } else {
      if { "$thisc" == "<" } {
        set valid 0
      } else {
        if { "$valid" != "0" } {
          if { "$thisc" >= " " && "$thisc" <= "z" } {
            set outstuff "$outstuff$thisc"
            #if { [string length $outstuff] == 10 } {
              #puts "outstuff so far=$outstuff findLastThis=$findLastThis"
            #}
          }
        }
      }
    }
  }
  

  set donethisway 0
  set capitalfound [expr {0 - 1}]
  set funnyfound [expr {0 - 1}]
  for {set iii 0} {$iii < [string length "$outstuff"]} {set iii [expr $iii+1]} {
    set thisc [string range "$outstuff" $iii $iii]
    if { "$thisc" > "z" && [expr {("$capitalfound")}] < 0 } {
      set funnyfound $iii
    } else {
      if { [expr {("$capitalfound")}] < 0 } {
        if { "$thisc" >= "A" && "$thisc" <= "Z" } {
          set capitalfound $iii
        }
      } else {
        if { "$thisc" == ";" && [string range "$outstuff" $iii [expr {$iii + 2}]] == ";  " } {
          set capitalfound [expr {$iii + 2}]
        } else {
        if { "$thisc" == ")" && [string range "$outstuff" $iii [expr {$iii + 3}]] == ")v. " } {
          set capitalfound [expr {$iii + 3}]
        } else {
        if { "$thisc" == ")" && [string range "$outstuff" $iii [expr {$iii + 3}]] == ")n. " } {
          set capitalfound [expr {$iii + 3}]
        } else {
        if { "$donethisway" == "0" && "$thisc" == "." && [string range "$outstuff" [expr {$iii + 1}] [expr {$iii + 1}]] >= "A" && [string range "$outstuff" [expr {$iii + 1}] [expr {$iii + 1}]] <= "Z" } {
          set capitalfound [expr {$iii + 1}]
          set donethisway 1
        }
        }
        }
        }
      }
    }
  }
  
  if { [expr {($capitalfound)}] > [expr {($funnyfound)}] } {
    
     set outstuff [string range "$outstuff" [expr {$capitalfound - 1}] 1000]
     set outstuff " >$outstuff"
  }

}

#puts "stuff in=$stuff"
#puts "stuff out=$outstuff"
return $outstuff
}

proc clueForWord {theWord tTry} {
global worder numthings phraseTry phraseBigTry
global desperateword  desperatecount
global desperatecontents desperaterating desperatebackup
global desperateclue corder donealready
set badret ""
set alturl ""
set altalturl ""
set slashspan "/span"
set cluestuff ""
set offset 0
set ourdiv "/div>"

#puts "clueForWord $theWord $tTry"

foreach hhh "$tTry" {
  set thirdTry "$hhh"
}

set found 0
foreach tt "$donealready" {
  if { "$thirdTry$theWord" == "$tt" } {
    set found 1
    return ""
  }
} 

if { "$found" == "0" } {
set donealready "$donealready $thirdTry$theWord"
}

for {set i 1} {$i <= $numthings} {set i [expr $i+1]} {
if { "$theWord" == "$worder($i)" } {
return ""
}
}
        set afind [expr {0}]
        set clue ""
        set ifind 0

   if { "$thirdTry" == "$tTry" } {
   set first "/span"
     set url "http://www.onelook.com/?w=$theWord"
     } else {
     set first "pseg"

     set url "http://www.thefreedictionary.com/$theWord"
     set alturl "http://www.encyclopedia.thefreedictionary.com/$theWord"
     set altalturl "http://www.medical-dictionary.thefreedictionary.com/$theWord"
              if { [expr {$desperaterating}] < 1 } {
				set desperateclue "you're lucky day ... $theWord"
				set desperatecontents "$theWord"
                set desperaterating 1
              }
     
    # puts "url=$url"
     }
     
     set desperatebackup "$theWord"
     
        if {[catch {set r [http::geturl $url -binary 1]} err]} { return $err }
        if {[catch {set html [http::data $r]} err]} { set html " " }
        
   if { "$thirdTry" == "$tTry" } {
          set afind [ourstringfirst $html "Quick" $afind]
                  if { [expr {($afind)}] > 0 } {
              if { [expr {$desperaterating}] < 2 } {
                set desperatecontents "$theWord"
                set desperaterating 2
				set desperateclue "you're lucky day ... $theWord"
              }
          set afinds [ourstringfirst $html "/span" $afind]
                  if { [expr {($afinds)}] < 0 } {
                    set slashspan "Quick"
                    set thirdTry "br>"
                    set tTry "br>"
        set afind [expr {$afind - 2}]
                  }
                  } else {
     set first "pseg"

     set url "http://www.thefreedictionary.com/$theWord"
     set alturl "http://www.encyclopedia.thefreedictionary.com/$theWord"
     set altalturl "http://www.medical-dictionary.thefreedictionary.com/$theWord"
				set desperateclue "you're lucky day ... $theWord"
				set desperatecontents "$theWord"
     
  #   puts "url=$url"
        if {[catch {set r [http::geturl $url -binary 1]} err]} { return $err }
        if {[catch {set html [http::data $r]} err]} { set html " " }
        set tTry " $tTry"
        set afind [expr {0}]
                  }
          
   } 
   
   if { "$thirdTry" != "$tTry" } {
           set afind [ourstringfirst $html "$first" $afind]
                  if { [expr {($afind)}] < 0 } {
        set afind [expr {0}]
         set afind [ourstringfirst $html "<div class=Syn>" $afind]
                  if { [expr {($afind)}] > 0 } {
                   set first "<div class=Syn>"
                   set ourdiv "div class=Syn>"
                   set offset 200
                  } else {
        set afind [expr {0}]
         set afind [ourstringfirst $html "<div id=MainTxt>" $afind]
         
                  if { [expr {($afind)}] > 0 } {
              if { [expr {$desperaterating}] < 3 } {
                set desperatecontents "$theWord"
                set desperaterating 3
				set desperateclue "you're lucky day ... $theWord"
              }
                   set first "<div id=MainTxt>"
         set afindw [ourstringfirst $html "h2>" $afind]
         set afindx [ourstringfirst $html "<a onmouseover" $afind]
         set afindy [ourstringfirst $html "/ul>" $afind]
         set afindz [ourstringfirst $html "/td></tr>" $afind]
                   if { [expr {($afindw)}] > 0 && ([expr {($afindy)}] < 0 || [expr {($afindw)}] < [expr {($afindy)}]) && ([expr {($afindz)}] < 0 || [expr {($afindw)}] < [expr {($afindz)}]) && ([expr {($afindx)}] < 0 || [expr {($afindw)}] > [expr {($afindx)}]) } {
                   set ourdiv "h2>"
                   } else {
                   if { [expr {($afindy)}] > 0 && ([expr {($afindz)}] < 0 || [expr {($afindy)}] < [expr {($afindz)}]) && ([expr {($afindx)}] < 0 || [expr {($afindy)}] > [expr {($afindx)}]) } {
                   set ourdiv "/ul>"
                   } else {
                   
                   if { [expr {($afindx)}] > 0 && ([expr {($afindz)}] < 0 || [expr {($afindx)}] < [expr {($afindz)}]) } {
                   set ourdiv "a onmouseover"
                   } else {
                   set ourdiv "/td></tr>"
                   }
                   }
                   }
                   set offset 2
        set afind [expr {$afind - 2}]
        
                  } else {
        
        set afind [expr {0}]
         set afind [ourstringfirst $html "<div id=ThesaurusInner>" $afind]
                  if { [expr {($afind)}] > 0 } {
              if { [expr {$desperaterating}] < 3 } {
                set desperatecontents "$theWord"
                set desperaterating 3
				set desperateclue "you're lucky day ... $theWord"
              }
                   set first "<div id=ThesaurusInner>"
         set afindw [ourstringfirst $html "h2>" $afind]
         set afindx [ourstringfirst $html "<a onmouseover" $afind]
         set afindy [ourstringfirst $html "/ul>" $afind]
         set afindz [ourstringfirst $html "/td></tr>" $afind]
                   if { [expr {($afindw)}] > 0 && ([expr {($afindy)}] < 0 || [expr {($afindw)}] < [expr {($afindy)}]) && ([expr {($afindz)}] < 0 || [expr {($afindw)}] < [expr {($afindz)}]) && ([expr {($afindx)}] < 0 || [expr {($afindw)}] > [expr {($afindx)}]) } {
                   set ourdiv "h2>"
                   } else {
                   if { [expr {($afindy)}] > 0 && ([expr {($afindz)}] < 0 || [expr {($afindy)}] < [expr {($afindz)}]) && ([expr {($afindx)}] < 0 || [expr {($afindy)}] > [expr {($afindx)}]) } {
                   set ourdiv "/ul>"
                   } else {
                   if { [expr {($afindx)}] > 0 && ([expr {($afindz)}] < 0 || [expr {($afindx)}] < [expr {($afindz)}]) } {
                   set ourdiv "a onmouseover"
                   } else {
                   set ourdiv "/td></tr>"
                   }
                   }
                   }
                   set offset 2
        set afind [expr {$afind - 2}]
                  } 
                  
                  }

                      if { "$alturl" != "" && "$offset" == "0" } {
         # puts "pre pre pre here x"
         set afindb [ourstringfirst $html "is not available in" 0]
         if { [expr {($afindb)}] > 0 } {
         set afindc [ourstringfirst $html " href=" $afindb]
         if { [expr {($afindc)}] > 0 } {
          set iiuu 0
          set qwtt [string range "$html" $afindc [expr {$afindc + 200}]]
          #puts "xhere x $qwtt"
          foreach hhh [split [string range $html $afindc [expr {$afindc + 200}]] "\""] {
            set iiuu [expr {$iiuu + 1}]
           #puts "hhh iiuu =$hhh $iiuu"
            if { "$iiuu" == "2" } {
              set alturl "$hhh"
              #puts "xalt put to $hhh"
            }
          }
           
         } else {
            set alturl ""
         }
         } else {
            set alturl ""
         }
         }

         
                      if { "$alturl" != "" && "$offset" == "0" } {
        if {[catch {set r [http::geturl $alturl -binary 1]} err]} { return $err }
        if {[catch {set html [http::data $r]} err]} { set html " " }
      #  puts "will try $alturl ... $desperaterating $desperatecontents"
        set afind [expr {0}]
         set afind [ourstringfirst $html "<h2>" $afind]
                  if { [expr {($afind)}] > 0 } {
              if { [expr {$desperaterating}] < 4 } {
                set desperatecontents "$theWord"
                set desperaterating 4
				set desperateclue "you're lucky day ... $theWord"
              }
                   set first "<h2>"
                   set ourdiv "h2>"
                   set offset 200
                  }
        set afind [expr {0}]
         
         
                      }
                  }
                  } else {
        set afind [expr {$afind - 2}]
                  }
   }
                  if { [expr {($afind)}] < 0 } {
        set afind [expr {0}]
                  }


        
        if { [expr {($afind)}] >= 0 } {
          set afind [ourstringfirst $html "$first" $afind]
          #puts "clue 1"
          if { [expr {($afind)}] > 0 } {
              if { [expr {$desperaterating}] < 5 } {
                set desperatecontents "$theWord"
                set desperaterating 5
				set desperateclue "you're lucky day ... $theWord"
              }
            set afindnext "$afind"
            
   if { "$thirdTry" == "$tTry" } {
            set afindnext [ourstringfirst $html "$slashspan" [expr {$afind + 1}]]
   } else {
            set afindnext [expr {$afindnext - $offset}]
   }
          #puts "clue 2"
            if { [expr {($afindnext)}] > 0 } {
   if { "$thirdTry" == "$tTry" } {
              set ifind [ourstringfirst $html "$thirdTry" [expr {$afindnext + 1}]]
   } else {
              set ifind [ourstringfirst $html "$ourdiv" [expr {$afindnext + 1}]]
              set ifindtwo [ourstringfirst $html "/span><$ourdiv" [expr {$afindnext + 1}]]
              if { [expr {($ifindtwo)}] > 0 && [expr {($ifind) - ($ifindtwo)}] > 0 } {
                set ifind $ifindtwo
              }
   }
          #puts "clue 3: $ifind"
          
        if { [expr {($ifind)}] > 0 && "$thirdTry" == "/span" } {
              if { [expr {$desperaterating}] < 6 } {
                set desperatecontents "$theWord"
                set desperaterating 6
				set desperateclue "you're lucky day ... $theWord"
              }
          set badret " "
              if { "$ourdiv" == "h2>" } {
              set cluest [string range $html [expr {$ifind - 802}] [expr {$ifind - 2}]]
              set cluestuff [eval {getRidOfChevronStuff "$cluest" "<br>"}]
              } else {
              set cluest [string range $html [expr {$ifind - 402}] [expr {$ifind - 2}]]
              set afindq [ourstringfirst "$cluest" "pseg" 0]
              set afindr [ourstringfirst "$cluest" "</b>" 0]
              set afinds [ourstringfirst "$cluest" "/span" 0]
              set afindt [ourstringfirst "$cluest" "<div" 0]
              
              set comp "</b>"
              if { [expr {($afindq)}] > 0 } {
                set comp "pseg"
              } else {
              if { [expr {($afinds)}] > 0 } {
                set comp "/span"
              } else {
              if { [expr {($afindt)}] > 0 } {
                set comp "<div"
              }
              }
              }
              set cluestuff [eval {getRidOfChevronStuff "$cluest" "$comp"}]
              }
              
              if { [ourstringfirst "$cluestuff" "<span class=\"illustration\">" 0] >= 0 } {
              while { [ourstringfirst "$cluestuff" "<span class=\"illustration\">" 0] >= 0 } {
                set iitt [ourstringfirst "$cluestuff" "<span class=\"illustration\">" 0]
                set pref [string range "$cluestuff" 0 [expr {$iitt - 1}]]
                set suff [string range "$cluestuff" [expr {$iitt + 1*0 + 27}] 1000]
                set cluestuff "$pref$suff"
         #       puts "new cluestuff=$cluestuff"
              }
              }
              if { [ourstringfirst "$cluestuff" "<i>" 0] >= 0 } {
              while { [ourstringfirst "$cluestuff" "<i>" 0] >= 0 } {
                set iitt [ourstringfirst "$cluestuff" "<i>" 0]
                set pref [string range "$cluestuff" 0 [expr {$iitt - 1}]]
                set suff [string range "$cluestuff" [expr {$iitt + 1*0 + 3}] 1000]
                set cluestuff "$pref$suff"
        #        puts "new cluestuff=$cluestuff"
              }
              }
              if { [ourstringfirst "$cluestuff" "</i>" 0] >= 0 } {
              while { [ourstringfirst "$cluestuff" "</i>" 0] >= 0 } {
                set iitt [ourstringfirst "$cluestuff" "</i>" 0]
                set pref [string range "$cluestuff" 0 [expr {$iitt - 1}]]
                set suff [string range "$cluestuff" [expr {$iitt + 1*0 + 4}] 1000]
                set cluestuff "$pref$suff"
        #        puts "new cluestuff=$cluestuff"
              }
              }
              if { [ourstringfirst "$cluestuff" "<b>" 0] >= 0 } {
              while { [ourstringfirst "$cluestuff" "<b>" 0] >= 0 } {
                set iitt [ourstringfirst "$cluestuff" "<b>" 0]
                set pref [string range "$cluestuff" 0 [expr {$iitt - 1}]]
                set suff [string range "$cluestuff" [expr {$iitt + 1*0 + 3}] 1000]
                set cluestuff "$pref$suff"
       #         puts "new cluestuff=$cluestuff"
              }
              }
              if { [ourstringfirst "$cluestuff" "</b>" 0] >= 0 } {
              while { [ourstringfirst "$cluestuff" "</b>" 0] >= 0 } {
                set iitt [ourstringfirst "$cluestuff" "</b>" 0]
                set pref [string range "$cluestuff" 0 [expr {$iitt - 1}]]
                set suff [string range "$cluestuff" [expr {$iitt + 1*0 + 4}] 1000]
                set cluestuff "$pref$suff"
     #           puts "new cluestuff=$cluestuff"
              }
              }
              if { [ourstringfirst "$cluestuff" "</a>" 0] >= 0 } {
              while { [ourstringfirst "$cluestuff" "</a>" 0] >= 0 } {
                set iitt [ourstringfirst "$cluestuff" "</a>" 0]
                set pref [string range "$cluestuff" 0 [expr {$iitt - 1}]]
                set suff [string range "$cluestuff" [expr {$iitt + 1*0 + 4}] 1000]
                set cluestuff "$pref$suff"
     #           puts "new cluestuff=$cluestuff"
              }
               }
              
              if { [ourstringfirst "$cluestuff" "<em>" 0] >= 0 } {
             
              while { [ourstringfirst "$cluestuff" "<em>" 0] >= 0 } {
                set iitt [ourstringfirst "$cluestuff" "<em>" 0]
                set pref [string range "$cluestuff" 0 [expr {$iitt - 1}]]
                set suff [string range "$cluestuff" [expr {$iitt + 1*0 + 4}] 1000]
                set cluestuff "$pref$suff"
     #           puts "new cluestuff=$cluestuff"
              }

              }


              if { [ourstringfirst "$cluestuff" "<altname>" 0] >= 0 } {

              while { [ourstringfirst "$cluestuff" "<altname>" 0] >= 0 } {
                set iitt [ourstringfirst "$cluestuff" "<altname>" 0]
                set pref [string range "$cluestuff" 0 [expr {$iitt - 1}]]
                set suff [string range "$cluestuff" [expr {$iitt + 1*0 + 9}] 1000]
                set cluestuff "$pref$suff"
        #        puts "new cluestuff=$cluestuff"
              }
              }
             if { [ourstringfirst "$cluestuff" "</altname>" 0] >= 0 } {
             while { [ourstringfirst "$cluestuff" "</altname>" 0] >= 0 } {
                set iitt [ourstringfirst "$cluestuff" "</altname>" 0]
                set pref [string range "$cluestuff" 0 [expr {$iitt - 1}]]
                set suff [string range "$cluestuff" [expr {$iitt + 1*0 + 10}] 1000]
                set cluestuff "$pref$suff"
       #         puts "new cluestuff=$cluestuff"
              }
              }
              
              if { [ourstringfirst "$cluestuff" "</div>" 0] > 0 } {
              
              while { [ourstringfirst "$cluestuff" "</div>" 0] > 0 } {
                set iitt [ourstringfirst "$cluestuff" "</div>" 0]
                set pref [string range "$cluestuff" 0 [expr {$iitt - 1}]]
                set suff [string range "$cluestuff" [expr {$iitt + 1*0 + 6}] 1000]
                set cluestuff "$pref$suff"
        #        puts "new cluestuff=$cluestuff"
              }
              }
              
              set startclue [ourstringlast "$cluestuff" ">" 0]
              
              if { [expr {($startclue)}] > 0 } {
		      set clue [string range "$cluestuff" [expr {($startclue) + 1}] 1000]
		      if { [ourstringfirst "$clue" " pronunciation" 0] > 0 } {
              set ifind [ourstringfirst $html "br>" [expr {$afindnext + 1}]]
              set badret ""
              if { [expr {($ifind)}] < 0 } {
              if { "$desperatecontents" == "$theWord" && "$desperaterating" != "0" } {
                set desperaterating [expr {$desperaterating - 1}]
              }
            return "$badret"
              }
		      }
              }
              
              }
              
            }
          } else {
              if { "$desperatecontents" == "$theWord" && "$desperaterating" != "0" } {
                set desperaterating [expr {$desperaterating - 1}]
              }
            return "$badret"
          }
        }
        
        if { [expr {($ifind)}] > 0 } {
        if { "$cluestuff" == "" || "$cluestuff" == "." || "$cluestuff" == " " } {
              set cluestuff [string range $html [expr {$ifind - 402}] [expr {$ifind - 2}]]
        }
              set startclue [ourstringlast "$cluestuff" ">" 0]
              
              if { [expr {($startclue)}] > 0 } {
              
              
	#	puts "word is $theWord"
		      set clue [string range "$cluestuff" [expr {($startclue) + 1}] 1000]
              set clue "$clue ([string length $theWord])"
		      set badstart [ourstringfirst "$clue" "nbsp" 0]
		      if { [expr {($badstart)}] > 0 } {
		      
		      while { [expr {($badstart)}] > 0 } {
		      set clue [string range $clue [expr {($badstart) + 5}] 1000]
		      set badstart [ourstringfirst "$clue" "nbsp" 0]
		      }
		      
		      }
      set llword "$theWord"
     foreach xq "aA eE iI oO uU yY bB cC dD fF gG hH jJ kK lL mM nN pP qQ rR sS tT vV wW xX zZ" {
		set hhh [ourstringfirst $llword "+" 0]
		if { [expr {($hhh)}] >= 0 } {
		  while { [expr {($hhh)}] >= 0 } {
		set llword [string replace $llword $hhh $hhh " "]
		set hhh [ourstringfirst $llword "+" 0]
		  }
		  }
		set hhh [ourstringfirst $llword [string range $xq 1 1] 0]
		if { [expr {($hhh)}] >= 0 } {
		  while { [expr {($hhh)}] >= 0 } {
		set llword [string replace $llword $hhh $hhh [string range $xq 0 0]]
		set hhh [ourstringfirst $llword [string range $xq 1 1] 0]
		  }
		  }
		  }
          set onechar [string range $theWord 0 0] 
          set notonechar [string range $llword 1 1000] 

		      set badstart [ourstringfirst "$clue" "$llword " 0]
		      while { [expr {($badstart)}] == 0 } {
		      set pref ""
		      set suff [string range $clue [expr {($badstart) + [string length $theWord] + 1*0}] 1000]
              set clue "$pref$suff"
		      set badstart [ourstringfirst "$clue" "$llword " 0]
		      }
		      set badstart [ourstringfirst "$clue" "$llword, " 0]
		      while { [expr {($badstart)}] == 0 } {
		      set pref ""
		      set suff [string range $clue [expr {($badstart) + [string length $theWord] + 1*0 + 1}] 1000]
              set clue "$pref$suff"
		      set badstart [ourstringfirst "$clue" "$llword, " 0]
		      }
		      set badstart [ourstringfirst "$clue" "$llword: " 0]
		      while { [expr {($badstart)}] == 0 } {
		      set pref ""
		      set suff [string range $clue [expr {($badstart) + [string length $theWord] + 1*0 + 1}] 1000]
              set clue "$pref$suff"
		      set badstart [ourstringfirst "$clue" "$llword: " 0]
		      }
		      set badstart [ourstringfirst "$clue" "$llword's " 0]
		      while { [expr {($badstart)}] == 0 } {
		      set pref ""
		      set suff [string range $clue [expr {($badstart) + [string length $theWord] + 1*0 + 2}] 1000]
              set clue "$pref$suff"
		      set badstart [ourstringfirst "$clue" "$llword's " 0]
		      }
		      set badstart [ourstringfirst "$clue" "$onechar$notonechar " 0]
		      while { [expr {($badstart)}] >= 0 } {
		      set pref [string range $clue 0 [expr {($badstart)}]]
		      set suff [string range $clue [expr {($badstart) + [string length $theWord] + 1*0}] 1000]
              set clue "$pref$suff"
		      set badstart [ourstringfirst "$clue" "$onechar$notonechar " 0]
		      }
		      set badstart [ourstringfirst "$clue" "$theWord " 0]
		      while { [expr {($badstart)}] == 0 } {
		      set pref [string range $clue 0 [expr {($badstart)}]]
		      set suff [string range $clue [expr {($badstart) + [string length $theWord] + 1*0}] 1000]
              set clue "$pref$suff"
		      set badstart [ourstringfirst "$clue" "$theWord " 0]
		      }
		      set badstart [ourstringfirst "$clue" "$theWord's " 0]
		      while { [expr {($badstart)}] == 0 } {
		      set pref [string range $clue 0 [expr {($badstart)}]]
		      set suff [string range $clue [expr {($badstart) + [string length $theWord] + 1*0 + 2}] 1000]
              set clue "$pref$suff"
		      set badstart [ourstringfirst "$clue" "$theWord's " 0]
		      }
		      set badstart [ourstringfirst "$clue" "$theWord, " 0]
		      while { [expr {($badstart)}] == 0 } {
		      set pref [string range $clue 0 [expr {($badstart)}]]
		      set suff [string range $clue [expr {($badstart) + [string length $theWord] + 1*0 + 1}] 1000]
              set clue "$pref$suff"
		      set badstart [ourstringfirst "$clue" "$theWord, " 0]
		      }
		      set badstart [ourstringfirst "$clue" "$theWord: " 0]
		      while { [expr {($badstart)}] == 0 } {
		      set pref [string range $clue 0 [expr {($badstart)}]]
		      set suff [string range $clue [expr {($badstart) + [string length $theWord] + 1*0 + 1}] 1000]
              set clue "$pref$suff"
		      set badstart [ourstringfirst "$clue" "$theWord: " 0]
		      }



		      set badstart [ourstringfirst "$clue" " $llword " 0]
		      while { [expr {($badstart)}] > 0 } {
		      set pref [string range $clue 0 [expr {($badstart)}]]
		      set suff [string range $clue [expr {($badstart) + [string length $theWord] + 1}] 1000]
              set clue "$pref$suff"
		      set badstart [ourstringfirst "$clue" " $llword " 0]
		      }
		      set badstart [ourstringfirst "$clue" " $onechar$notonechar " 0]
		      while { [expr {($badstart)}] > 0 } {
		      set pref [string range $clue 0 [expr {($badstart)}]]
		      set suff [string range $clue [expr {($badstart) + [string length $theWord] + 1}] 1000]
              set clue "$pref$suff"
		      set badstart [ourstringfirst "$clue" " $onechar$notonechar " 0]
		      }
		      set badstart [ourstringfirst "$clue" "$onechar$notonechar's " 0]
		      while { [expr {($badstart)}] > 0 } {
		      set pref [string range $clue 0 [expr {($badstart)}]]
		      set suff [string range $clue [expr {($badstart) + [string length $theWord] + 2}] 1000]
              set clue "$pref$suff"
		      set badstart [ourstringfirst "$clue" "$onechar$notonechar's " 0]
		      }
		      set badstart [ourstringfirst "$clue" "$onechar$notonechar, " 0]
		      while { [expr {($badstart)}] > 0 } {
		      set pref [string range $clue 0 [expr {($badstart)}]]
		      set suff [string range $clue [expr {($badstart) + [string length $theWord] + 1}] 1000]
              set clue "$pref$suff"
		      set badstart [ourstringfirst "$clue" "$onechar$notonechar, " 0]
		      }
		      set badstart [ourstringfirst "$clue" "$onechar$notonechar: " 0]
		      while { [expr {($badstart)}] > 0 } {
		      set pref [string range $clue 0 [expr {($badstart)}]]
		      set suff [string range $clue [expr {($badstart) + [string length $theWord] + 1}] 1000]
              set clue "$pref$suff"
		      set badstart [ourstringfirst "$clue" "$onechar$notonechar: " 0]
		      }
		      set badstart [ourstringfirst "$clue" " $theWord " 0]
		      while { [expr {($badstart)}] > 0 } {
		      set pref [string range $clue 0 [expr {($badstart)}]]
		      set suff [string range $clue [expr {($badstart) + [string length $theWord] + 1}] 1000]
              set clue "$pref$suff"
		      set badstart [ourstringfirst "$clue" " $theWord " 0]
		      }

		      set badstart [ourstringfirst "$clue" " $llword." 0]
		      while { [expr {($badstart)}] > 0 } {
		      set pref [string range $clue 0 [expr {($badstart)}]]
		      set suff [string range $clue [expr {($badstart) + [string length $theWord] + 1}] 1000]
              set clue "$pref$suff"
		      set badstart [ourstringfirst "$clue" " $llword." 0]
		      }
		      set badstart [ourstringfirst "$clue" " $onechar$notonechar." 0]
		      while { [expr {($badstart)}] > 0 } {
		      set pref [string range $clue 0 [expr {($badstart)}]]
		      set suff [string range $clue [expr {($badstart) + [string length $theWord] + 1}] 1000]
              set clue "$pref$suff"
		      set badstart [ourstringfirst "$clue" " $onechar$notonechar." 0]
		      }
		      set badstart [ourstringfirst "$clue" " $theWord." 0]
		      while { [expr {($badstart)}] > 0 } {
		      set pref [string range $clue 0 [expr {($badstart)}]]
		      set suff [string range $clue [expr {($badstart) + [string length $theWord] + 1}] 1000]
              set clue "$pref$suff"
		      set badstart [ourstringfirst "$clue" " $theWord." 0]
		      }


              if {  [string range "$clue" 0 2] == ") (" || [string range "$clue" 0 1] == " (" ||  [string range "$clue" 0 2] == "  (" ||  [string range "$clue" 0 3] == "   (" } { 
              if { [expr {$desperaterating}] < 8 } {
                set desperatecontents "$theWord"
                set desperaterating 8
				set desperateclue "you're lucky day ... $theWord ... $clue"
              }
              if { "$desperatecontents" == "$theWord" && "$desperaterating" != "0" } {
                set desperaterating [expr {$desperaterating - 1}]
              }
                return "$badret"
              } else {
              if { [expr {$desperaterating}] < 25 } {
                set desperatecontents "$theWord"
                set desperaterating 25
				set desperateclue "you're lucky day ... $theWord ... $clue"
              }
              }
             # puts "clue is $clue"
              if { "$clue" != "" } {
               set isok 0
for {set ii 1} {$ii <= [string length "$clue"]} {set ii [expr $ii+1]} {
set huhhuh [string range "$clue" [expr {$ii - 1}] [expr {$ii - 1}]]
if { ("$huhhuh" >= "A" && "$huhhuh" <= "Z") || ("$huhhuh" >= "a" && "$huhhuh" <= "z")  } {
 set isok 1
}
}
if { "$isok" == "0" || [string range "$clue" 0 16] == ".S. pronunciation" } {
  set clue ""
}
              }
              return "$clue"
              }
              
        }
              if { "$desperatecontents" == "$theWord" && "$desperaterating" != "0" } {
                set desperaterating [expr {$desperaterating - 1}]
              }
        return "$badret"
}

set altalt(1) "ISOK"
set cluealtalt(1) "all alright (coll.) (2,2)"
set altalt(2) "AKID"
set cluealtalt(2) "one baby goat (1,3)"
set altalt(3) "IRAJ"
set cluealtalt(3) "declare to be Indian leader? (1,3)"
set altalt(4) "XRAY"
set cluealtalt(4) "method to see inside body (4)"
set altalt(5) "AJAR"
set cluealtalt(5) "not fully shut (4)"
set altalt(6) "SOHO"
set cluealtalt(6) "suburb of London (4)"
set altalt(7) "QWERTY"
set cluealtalt(7) "keyboard type (6)"
set altalt(8) "QATAR"
set cluealtalt(8) "Middle East country (5)"
set altalt(9) "IRAQ"
set cluealtalt(9) "Middle East country (4)"
set altalt(10) "KUWAIT"
set cluealtalt(10) "Middle East country (6)"
set altalt(11) "BHUTAN"
set cluealtalt(11) "Asian country (6)"
set altalt(12) "JAPAN"
set cluealtalt(12) "Asian country (5)"
set altalt(13) "SIKKIM"
set cluealtalt(13) "Asian country (6)"
set altalt(14) "SIOUX"
set cluealtalt(14) "Red Indian tribe (5)"
set altalt(15) "TIMBUKTU"
set cluealtalt(15) "place in the Sahara Desert (8)"
set altalt(16) "ASIX"
set cluealtalt(16) "big hit in cricket (1,3)"
set altalt(17) "SANSSERIF"
set cluealtalt(17) "style of font (4,5)"
set altalt(18) "MERCI"
set cluealtalt(18) "thank you (French) (5)"
set altalt(19) "RADII"
set cluealtalt(19) "several circle measures (5)"
set altalt(20) "KHAKI"
set cluealtalt(20) "colour; military style of clothing (5)"
set altalt(21) "KHYBER"
set cluealtalt(21) "pass in India (6)"
set altalt(22) "LAPAZ"
set cluealtalt(22) "capital of Bolivia (5)"
set altalt(23) "BARTOK"
set cluealtalt(23) "classical composer (6)"
set altalt(24) "ZEPHYR"
set cluealtalt(24) "blimp (6)"
set altalt(25) "OMAN"
set cluealtalt(25) "Middle East country (4)"
set altalt(26) "SLAV"
set cluealtalt(26) "person from the Balkans (4)"
set altalt(27) "RUBIK"
set cluealtalt(27) "inventor of cube puzzle (5)"
set altalt(28) "KRYPTON"
set cluealtalt(28) "Superman's achilles heal (7)"
set altalt(29) "XAVIER"
set cluealtalt(29) "quite popular boy's name (6)"


set altalt(30) "PYREX"
set cluealtalt(30) "used to make cooking dishes (5)"
set altalt(31) "XANTHEA"
set cluealtalt(31) "quite popular girl's name (7)"
set altalt(32) "XVII"
set cluealtalt(32) "seventeen in Roman numerals (4)"
set altalt(33) "XXVIII"
set cluealtalt(33) "twenty eight in Roman numerals (6)"
set altalt(34) "XXVII"
set cluealtalt(34) "twenty seven in Roman numerals (5)"
set altalt(35) "MDCCCI"
set cluealtalt(35) "1801 in Roman numerals (5)"
set altalt(36) "LXVI"
set cluealtalt(36) "sixty six in Roman numerals (4)"
set altalt(37) "RUBIK"
set cluealtalt(37) "inventor of cube puzzle (5)"
set altalt(38) "JAZZCLUB"
set cluealtalt(38) "place to hear live music (4,4)"
set altalt(39) "KTEL"
set cluealtalt(39) "steak knife supplier? (4)"


set altalt(40) "YPRES"
set cluealtalt(40) "place in France (5)"
set altalt(41) "YIPPEE"
set cluealtalt(41) "shout of joy (coll.) (6)"
set altalt(42) "LVII"
set cluealtalt(42) "fifty seven in Roman numerals (4)"
set altalt(43) "LXVIII"
set cluealtalt(43) "sixty eight in Roman numerals (6)"
set altalt(44) "MXVII"
set cluealtalt(44) "1017 in Roman numerals (5)"
set altalt(45) "DCCCII"
set cluealtalt(45) "802 in Roman numerals (5)"
set altalt(46) "LXII"
set cluealtalt(46) "sixty two in Roman numerals (4)"
set altalt(47) "AGNU"
set cluealtalt(47) "one animal with long snout (1,3)"
set altalt(48) "ANEMU"
set cluealtalt(48) "one large bird (2,3)"
set altalt(49) "AGNEW"
set cluealtalt(49) "former US vice president (5)"



set altalt(50) "VESUVIUS"
set cluealtalt(50) "Italian volcano (8)"
set altalt(51) "WYCOMBE"
set cluealtalt(51) "place in England (7)"
set altalt(52) "MMII"
set cluealtalt(52) "2002 in Roman numerals (5)"
set altalt(53) "LXXIII"
set cluealtalt(53) "seventy three in Roman numerals (6)"
set altalt(54) "MXIII"
set cluealtalt(54) "1013 in Roman numerals (5)"
set altalt(55) "DCCCVI"
set cluealtalt(55) "806 in Roman numerals (6)"
set altalt(56) "LXIV"
set cluealtalt(56) "sixty four in Roman numerals (4)"
set altalt(57) "ISPY"
set cluealtalt(57) "children's game (1,3)"
set altalt(58) "JIGSAW"
set cluealtalt(58) "type of puzzle (6)"
set altalt(59) "TREX"
set cluealtalt(59) "dinosaur (coll.) (1,3)"

set altalt(60) "ITAG"
set cluealtalt(60) "what a child might say during red rover? (1,3)"
set altalt(61) "SUSSORB"
set cluealtalt(61) "strange sphere? (coll.) (4,3)"
set altalt(62) "FOXTROT"
set cluealtalt(62) "dance (3,4)"
set altalt(63) "NOTAROT"
set cluealtalt(63) "refuse superstition? (2,5)"
set altalt(64) "WITHTOT"
set cluealtalt(64) "accompany baby? (4,3)"
set altalt(65) "DRYROT"
set cluealtalt(65) "wood disease (3,3)"
set altalt(66) "SITALOT"
set cluealtalt(66) "be sedentary? (3,1,3)"
set altalt(67) "LENOWEME"
set cluealtalt(67) "Leonard is in your debt? (3,3,2)"

set numaltalt 67

proc altaltinventWord {help whichword xLen altHelp desperation} {
  global altalt numaltalt cluealtalt corder worder difficulty
  
  for {set i 1} {$i <= $numaltalt} {set i [expr $i+1]} {
    if { [expr {$xLen}] == [string length $altalt($i)] } {
     set ok 1
     for {set j 0} {$j < $xLen} {set j [expr $j+1]} {
       if { [string range $altalt($i) $j $j] != [string range $help $j $j] } {
         if { [string range $help $j $j] != "+" } {
			set ok 0
         }
       }
     }
     if { $ok != 0 } {
       set corder($whichword) "$cluealtalt($i)"
       return "$altalt($i)"
     }
    }
  }
  
}

proc altinventWord {help whichword xLen altHelp desperation} {
 global url html filename talk percent pb corder sorder worder goodNonChar okpos
 global cn cv shownword _shownword _ourword desperaterating donealready
 global numplay xc nogosuffix phraseTry phraseBigTry desperatecontents desperateclue difficulty
          
           if { [expr {$desperaterating}] >= 25 } {
         #    puts "desperate Return $desperatecontents RE $desperaterating"
             return "$desperatecontents"
           }
           
 set numplay $numplay
 set invalid "y"
 set cluepref ""
 set zzz "zzz" 
 set alturl ""
 set first "101"


 set doneoncebefore 0
 foreach fg "$donealready" {
   if { "/span$help" == "$fg" || "br>$help" == "$fg" } {
     set doneoncebefore 1
   }
 }

 set retval ""
 set btwo 0
 set zero 0
 set html ""
 if { "$desperation" == "0" } {
 set once "$desperation -0"
 } else {
 set once "$desperation"
 }
 set seven "7"
 
 set smallhelp "$help"
 
 if { [ourstringfirst "$smallhelp" "%3F" 0] >= 0 } {
#puts "here0"
 
 while { [ourstringfirst "$smallhelp" "%3F" 0] >= 0 } {
                set iitt [ourstringfirst "$smallhelp" "%3F" 0]
                set pref [string range $smallhelp 0 [expr {$iitt - 1}]]
                set suff [string range $smallhelp [expr {$iitt + 1*0 + 3}] 1000]
                set smallhelp "$pref$suff"
 }
 }
 
 if { [ourstringfirst "$smallhelp" "%27" 0] >= 0 } {
# puts "here1"
 
 while { [ourstringfirst "$smallhelp" "%27" 0] >= 0 } {
                set iitt [ourstringfirst "$smallhelp" "%27" 0]
                set pref [string range $smallhelp 0 [expr {$iitt - 1}]]
                set suff [string range $smallhelp [expr {$iitt + 1*0 + 3}] 1000]
                set smallhelp "$pref$suff"
 }
 }
 
 if { [ourstringfirst "$smallhelp" "*" 0] >= 0 } {
# puts "here2"
 
 
 while { [ourstringfirst "$smallhelp" "*" 0] >= 0 } {
                set iitt [ourstringfirst "$smallhelp" "*" 0]
                set pref [string range $smallhelp 0 [expr {$iitt - 1}]]
                set suff [string range $smallhelp [expr {$iitt + 1*0 + 1}] 1000]
                set smallhelp "$pref$suff"
 }
 }
 
 if { [ourstringfirst "$smallhelp" "?" 0] >= 0 } {
#  puts "here3"
 

 while { [ourstringfirst "$smallhelp" "?" 0] >= 0 } {
                set iitt [ourstringfirst "$smallhelp" "?" 0]
                set pref [string range $smallhelp 0 [expr {$iitt - 1}]]
                set suff [string range $smallhelp [expr {$iitt + 1*0 + 1}] 1000]
                set smallhelp "$pref$suff"
 }
  }
 
 if { [ourstringfirst "$smallhelp" "+" 0] >= 0 } {
# puts "here4"
 

 while { [ourstringfirst "$smallhelp" "+" 0] >= 0 } {
                set iitt [ourstringfirst "$smallhelp" "+" 0]
                set pref [string range $smallhelp 0 [expr {$iitt - 1}]]
                set suff [string range $smallhelp [expr {$iitt + 1*0 + 1}] 1000]
                set smallhelp "$pref$suff"
 }
 }
 
 if { [ourstringfirst "$smallhelp" "'" 0] >= 0 } {
# puts "here5"
 
 
 while { [ourstringfirst "$smallhelp" "'" 0] >= 0 } {
                set iitt [ourstringfirst "$smallhelp" "'" 0]
                set pref [string range $smallhelp 0 [expr {$iitt - 1}]]
                set suff [string range $smallhelp [expr {$iitt + 1*0 + 1}] 1000]
                set smallhelp "$pref$suff"
 }
 }
# puts "here6"
 
 
  foreach measure "$once" {  
   if { "$retval" == "" } {
   
   if { "$html" == "" } {
	if { [expr {$xLen}] <= 5 || [expr {$measure}] > 0 } {
	 if { [expr {$measure}] > 0 && "$phraseBigTry" != "" } {
	 if { [string length "$smallhelp"] <= 1 } {
     set posthelp "&scwo=1&sswo=0"
	 } else {
  
  if { "$difficulty" == "Easy" } {
     set posthelp "&scwo=1&sswo=0"
  } else {
     set posthelp "&scwo=1&scwo=0&sswo=0"
  }
     }
     set cluepref " "
     set url "http://www.onelook.com/?w=$phraseBigTry$posthelp"
     set pref [string range $phraseTry 0 2]
     set suff [string range $phraseBigTry 1 1000]
     set alturl "http://www.onelook.com/?w=$pref$suff$posthelp"
     set posthelp "&scwo=1&scwo=0&first=$first"
     set nexturl "http://www.onelook.com/?w=$phraseBigTry"
#     puts "url=$url"
	 } else {
     set posthelp "&ls=a"
     set url "http://www.onelook.com/?w=$help$posthelp"
     set posthelp ""
     set nexturl ""
     }
     } else {
	 if { [string length "$smallhelp"] <= 1 } {
     set posthelp "&scwo=1&sswo=1"
	 } else {
     set posthelp "&scwo=1&scwo=0&sswo=1"
     }
     set url "http://www.onelook.com/?w=$help$posthelp"
     set posthelp "&scwo=1&scwo=0&first=$first"
     set nexturl "http://www.onelook.com/?w=$help"
 #    puts "url=$url"
     }
     
     
     
#puts $url
     #set filename [file tail $url]
     #set r [http::geturl $url -binary 1]
          #    puts "looking for clues ... $desperatecontents $desperateclue ... $desperaterating ..."
        if {[catch {set r [http::geturl $url -binary 1]} err]} { return $err }
#puts $oursuffix
# set url [lindex $argv 0]
# set filename [file tail $url]
# set r [http::geturl $url -binary 1]
# set fo [open $filename w]
# fconfigure $fo -translation binary
# puts -nonewline $fo [http::data $r]
# close $fo
# ::http::cleanup $r
# puts "Got $url -> $filename"


#set html [http::data $r]
        if {[catch {set html [http::data $r]} err]} { set html " " }
        
       #       puts "may have found some clues ..."
              }
        #puts $html
        
        set afind [expr {0}]
        set finding(1) ""
        set ifind 0
        set num 0
        
        if { "$alturl" != "" } {
          set afind [ourstringfirst $html ". <a href=\"/?w" $afind]
        if  { [expr {($afind)}] < 0 } {
        set afind [expr {0}]
        if {[catch {set r [http::geturl $url -binary 1]} err]} { return $err }
        if {[catch {set html [http::data $r]} err]} { set html " " }
          set url "$alturl"
  #        puts "trying $alturl"
          set alturl ""
          }
        }

        while { [expr {$num % 100}] == 0 } {        
        while { [expr {($afind)}] >= 0 } {
          set afind [ourstringfirst $html ". <a href=\"/?w" $afind]
          #puts "afind=$afind"
          if { [expr {($afind)}] > 0 } {
          set num [expr {$num + 1}]
            set afindend [ourstringfirst $html "</a>" $afind]
          #puts "afindend=$afindend xLen=$xLen"
#160. <a href="/?w=wier-cook+airport">wier-cook airport</a><br>
#161. <a href="/?w=wier+cook+airport">wier cook airport</a><br>
            set pluscount 0
            set minuscount 0
            if { [expr {($afindend)}] > 0 } {
          for  {set j $afind} {$j <= $afindend} {set j [expr $j+1]} {
            if { [string range $html $j $j] == "+" } {
              set pluscount [expr {$pluscount + 1}]
            }
            if { [string range $html $j $j] == "-" } {
              set minuscount [expr {$minuscount + 1}]
            }
            }
           
          }
            
            if { [expr {$afindend - $afind - ($minuscount) - ($pluscount * 2)}] == [expr {$xLen * 2 + 17}] } {
            if { "$pluscount" != "0" } {
              set afindend [expr {$afindend - $xLen - ($minuscount / 2) - $pluscount - 2}]
            }
            if { "$minuscount" != "0" } {
              set afindend [expr {$afindend - $xLen - ($minuscount / 2) - $pluscount - 2}]
            }
              set finding([expr {$ifind + 1}]) [string range $html [expr {$afindend - $xLen - $pluscount - ($minuscount / 2)}] [expr {$afindend - 1}]]
            if { "$minuscount" != "0" } {
            set agood ""
            for {set i 0} {$i < [string length $finding([expr {$ifind + 1}])]} {set i [expr $i+1]} {
    if { ([string range $finding([expr {$ifind + 1}]) $i $i] >= "a" && [string range $finding([expr {$ifind + 1}]) $i $i] <= "z") || [string range $finding([expr {$ifind + 1}]) $i $i] == "-" } {
            set xgood [string range $finding([expr {$ifind + 1}]) $i $i]
            set agood "$agood$xgood"
            }
            }
            set  finding([expr {$ifind + 1}]) "$agood"
            }
            set wekkok 1
            if { "$cluepref" != "" && "$goodNonChar" != " " } {
            set wekkok 0
            set vsokpos 0
            for {set i 0} {$i < [string length $finding([expr {$ifind + 1}])]} {set i [expr $i+1]} {
    if { [string range $finding([expr {$ifind + 1}]) $i $i] >= "a" && [string range $finding([expr {$ifind + 1}]) $i $i] <= "z" } {
      set vsokpos [expr {$vsokpos + 1}]
      if { "$vsokpos" == "$okpos" } {
     set yy [string range $finding([expr {$ifind + 1}]) $i $i]
     foreach xq "aA eE iI oO uU yY bB cC dD fF gG hH jJ kK lL mM nN pP qQ rR sS tT vV wW xX zZ" {
       if { "$xq" == "$yy$goodNonChar" } {
            set wekkok 1
       }
     }
      }
    }
              
            }
            
            }
              set blstate [ourstringfirst $finding([expr {$ifind + 1}]) " " 0]
              set dtstate [ourstringfirst $finding([expr {$ifind + 1}]) "." 0]
              #set msstate [ourstringfirst $finding([expr {$ifind + 1}]) "-" 0]
              set msstate [ourstringfirst $finding([expr {$ifind + 1}]) "0" 0]
              foreach erw "0 1 2 3 4 5 6 7 8 9" {
                 if { [expr {($dtstate)}] < 0 } {
              set dtstate [ourstringfirst $finding([expr {$ifind + 1}]) "$erw" 0]
                 }
              }
              if { $wekkok != 0 && [expr {($blstate)}] < 0 && [expr {($dtstate)}] < 0 && [expr {($msstate)}] < 0 } {
              set ifind [expr {$ifind + 1}]
              #puts "finding($ifind)=$finding($ifind)"
              }
            }
            set afind [expr {$afind + 1}]
          }
        }
        
        if { [expr {$num}] == 0 && "$num" == "$zero"} {
        
        if { "$alturl" != "" } {

        set afind [expr {0}]
        if {[catch {set r [http::geturl $url -binary 1]} err]} { return $err }
        if {[catch {set html [http::data $r]} err]} { set html " " }
          set url "$alturl"
    #      puts "Trying $alturl"
          set alturl ""
          set seven "0"
          }
        
        } 
        
        
        if { [expr {$num % 100}] == 0 && "$num" != "$zero" && "$nexturl" != "" && [expr {$num}] < 1250 } {        
     set url "$nexturl$posthelp"
 #    puts "url=$url"
        if {[catch {set r [http::geturl $url -binary 1]} err]} { return $err }
        if {[catch {set html [http::data $r]} err]} { set html " " }
        set zero [expr {$zero + 100}]
        set first [expr {$first + 100}]
     set posthelp "&scwo=1&first=$first"
        set afind [expr {0}]
        } else {
          set num "$seven"
        }
        
        set seven "7"
        
        }
        
        if { $ifind != 0 } {
        set atry "/span br>"
        #if { [expr {$xLen}] <= 5 && [expr {$whichword}] < 15 } {
        # set atry "/span"
        #}
        set force ""
          foreach tries "$atry" {
          if { "$force" != "" } {
            set tries "$force"
          }
          
          set divider 1
          
          if { [expr {$ifind}] >= 100 } {
            set divider 10
          } else {
           if { [expr {$ifind}] >= 50 } {
            set divider 5
           } else {
            if { [expr {$ifind}] >= 20 } {
             set divider 2
           }
          }
         }
          
          for  {set j 0} {$j < [expr {($ifind / $divider)}]} {set j [expr $j+1]} {
          set ig [expr {1 + round(rand() * [expr {$ifind - 1}])}]
          #puts "ig=$ig"
     set hasvowel 0
     set iu 0
     foreach xq "aA eE iI oO uU yY bB cC dD fF gG hH jJ kK lL mM nN pP qQ rR sS tT vV wW xX zZ" {
        set iu [expr {$iu + 1}]
		set hhh [ourstringfirst $finding($ig) [string range $xq 0 0] 0]
		if { [expr {($hhh)}] >= 0 } {
		  if { [expr {$iu}] <= 6 } {
		    set hasvowel 1
		  }
		  while { [expr {($hhh)}] >= 0 } {
		set finding($ig) [string replace $finding($ig) $hhh $hhh [string range $xq 1 1]]
		#puts "finding($ig) becomes $finding($ig)"
		set hhh [ourstringfirst $finding($ig) [string range $xq 0 0] 0]
		  }
		  }
		  }
		  if { $hasvowel != 0 } {
	#	puts "finding($ig)=$finding($ig)"
		  set corder($whichword) [eval {clueForWord $finding($ig) "$cluepref$tries"}]
	#	puts "corder($whichword) =$corder($whichword) "
		  
		  if { ("$corder($whichword)" == " " ||  "$corder($whichword)" == "") && [ourstringfirst "$finding($ig)" "S+" 0] > 0 } {
           set iipp [ourstringfirst "$finding($ig)" "S+" 0]
           set ppref [string range "$finding($ig)" 0 [expr {$iipp - 1}]]
           set middle "'"
           set ssuff [string range "$finding($ig)" $iipp 1000]
           set xxrr "$ppref$middle$ssuff"
		   set corder($whichword) [eval {clueForWord "$xxrr" "$cluepref$tries"}]           
		  }
		  
		  if { "$corder($whichword)" == " " } {
		    set force "/span"
		    set corder($whichword) ""
		  }
		  if { "$corder($whichword)" != "" } {
              set retval "$finding($ig)"
      #        puts "return 1 retval=$retval measure=$measure"
		  return $finding($ig)
		  }
		  }
		  }
		  }
        } else {
          set qwt ""
  #        puts "measure=$measure doneoncebefore=$doneoncebefore"
          if { [expr {$measure}] == 0 && "$doneoncebefore" != "9999990" } {
          
           if { [expr {$desperaterating}] >= 25 } {
    #         puts "desperate return $desperatecontents RE $desperaterating"
             return "$desperatecontents"
           }
          
           set qwt [eval {altinventWord $help $whichword $xLen $altHelp 1}]
      #     puts "got back 1 qwt=$qwt"
           set retval "$qwt"
            set qwtx ""
            ##set qwtx [eval {inventWord $help $whichword $xLen $altHelp 9}]
      #     puts "got back 1a qwtx=$qwtx altHelp=$altHelp help=$help"
           set retval "$qwtx"
            if { "$qwtx" == "" && [string range $altHelp 0 0] != "%"  && [string range $help 0 0] != "+" && [string range $worder($whichword) 0 0] == " " } {
              set newah "%3F[string range $altHelp 1 1000]"
              set newh "+[string range $help 1 1000]"
              set qwtz [eval {altinventWord $newh $whichword $xLen $newah 1}]
      #     puts "got back 2 qwtz=$qwtz newsah=$newah newh=$newh"
              if { "$qwtz" == "" } {
              
              if { "$desperaterating" == "10" } {
              #set qwtzz [eval {altaltinventWord $newh $whichword $xLen $newah 1}]
              set qwtzz "$desperatecontents"
     #      puts "got back 3 qwtzz=$qwtzz"
              set retval "$qwtzz"
      #        puts "Return 2 qwtzz=$qwtzz measure=$measure"
			  return "$qwtzz"   
			  
			  
			  
              }
              set retval "$qwtz"
     #         puts "return 3 qwtz=$qwtz measure=$measure"
			  return "$qwtz"              
            }
              set retval "$qwtx"
      #        puts "return 4  qwtx=$qwtx measure=$measure"
            return "$qwtx"
           }
              set retval "$qwt"
    #          puts "return 5 qwt=$qwt measure=$measure"
           return "$qwt"
          #} else {
          # return "$retval"
          }
        }
    }
	}  
          
           if { [expr {$desperaterating}] >= 25 } {
     #        puts "desperate reTurn $desperatecontents RE $desperaterating"
             return "$desperatecontents"
           }
         #     puts "return 6 retval=$retval desperation=$desperation"
	return "$retval"
}

proc inventWord {help whichword xLen altHelp isdesperate} {
 global url html filename talk percent pb corder sorder
 global cn cv shownword _shownword _ourword
 global numplay xc nogosuffix desperatecontents desperaterating
 set numplay $numplay
 set invalid "y"
 set zzz "zzz" 
 set btwo 0
          
           if { [expr {$desperaterating}] >= 25 } {
   #          puts "Desperate return $desperatecontents RE $desperaterating"
             return "$desperatecontents"
           }
 
 #puts "at start of inventWord"

if { "$isdesperate" == "0" } {
   set yay [eval {altinventWord $help $whichword $xLen $altHelp $isdesperate}]
   if { "$yay" != "" } {
   return "$yay"
   } else {
   #new line below
   return ""
   }
}


if { [expr {$isdesperate}] < 5 } { 
 set xxx [eval alttry $altHelp $xLen]
 if { "$xxx" != "" } {
   set _ourword $xxx
   set corder($whichword) [eval {clueForWord $xxx "/span"}]
		  if { "$corder($whichword)" == " " } {
		    set corder($whichword) ""
		  } else {
   if { "$corder($whichword)" == "" } {
   set corder($whichword) [eval {clueForWord $xxx "br>"}]
   }
   }
   if { "$corder($whichword)" == "" } {
   set xxx [eval {altinventWord $xxx $whichword $xLen $altHelp $isdesperate}]
   #puts "this has to be something=$xxx"
   }
   return $xxx
 } else {
   set yay [eval {altinventWord $help $whichword $xLen $altHelp $isdesperate}]
   if { "$yay" != "" } {
   return "$yay"
   }
   if { "$isdesperate" != "0" } {
   return "$yay"
   }
 }
 }
	
	#$pb start
#set percent 0
 if { $invalid == "y" } {
 
     
     set oursuffix "$help" 
 #    
#   set percent [expr {round((($percent + 5)))}]
  # if { [expr {$percent}] >= 100.0 } {
  #   set percent 5
  # }
     set url "http://dictionary.reference.com/browse/$oursuffix"
#puts $url
     #set filename [file tail $url]
     #set r [http::geturl $url -binary 1]
        if {[catch {set r [http::geturl $url -binary 1]} err]} { return $err }
#puts $oursuffix
# set url [lindex $argv 0]
# set filename [file tail $url]
# set r [http::geturl $url -binary 1]
# set fo [open $filename w]
# fconfigure $fo -translation binary
# puts -nonewline $fo [http::data $r]
# close $fo
# ::http::cleanup $r
# puts "Got $url -> $filename"


#set html [http::data $r]
        if {[catch {set html [http::data $r]} err]} { set html " " }
 #  set percent [expr {round((($percent + 5)))}]

##set html [eval [hget [http::geturl $url -binary 0] data]]

#puts [string range $html 0 278]     


#::http::cleanup $r
        if {[catch {::http::cleanup $r} err]} { set url $url }


##setFileHttp

     set aone [ourstringfirst $html "</a> (in dictionary)" 0]


   	set atwo [ourstringfirst $html "</b></td></tr>" 0]
   	
   	# new below
   	if { [expr {($atwo)}] < 0 } {
     set atwo [ourstringfirst $html "</h2>" 0]
   	} else {
 #  	puts "newish atwo found"
	set atwo [expr {$atwo - 1}]
   	}


     #set athree [ourstringfirst $html "<" 0]
     set aword ""
#puts "g len=[string length html] len=[string length $html]"
#puts "aone=$aone atwo=$atwo athree=$athree firstchar=[string range $html 0 100]"
     if { $atwo < 0 } {
	        if { $aone > 0 } {
	            ##print 'aone=', aone
	            set zzz [string range $html [expr {$aone - $xLen - 1}] [expr {$aone - 1}]]
	            set bone [ourstringfirst $zzz ">" 0]
	            set btwo $bone
	            
	            ##print zzz[(bone + 1):].replace(" ", "+")
                    #webbrowser.open_new('http://dictionary.reference.com/browse/' + zzz[(bone + 1):].replace(" ", "+")) 
	            #html = urllib2.urlopen('http://dictionary.reference.com/browse/' + zzz[(bone + 1):].replace(" ", "+")).read()
		set oursuffix [string range $zzz [expr {$bone + 1}] 1000]
 #  set percent [expr {round((($percent + 5)))}]
#   if { [expr {$percent}] >= 100.0 } {
#     set percent 5
#   }
		set hhh [ourstringfirst $oursuffix " " 0]
		if { [expr {($hhh)}] >= 0 } {
		  while { [expr {($hhh)}] >= 0 } {
		set oursuffix [string replace $oursuffix $hhh $hhh "+"]
		set hhh [ourstringfirst $oursuffix " " 0]
		  }
		}
		set hhh [ourstringfirst $oursuffix "?" 0]
		if { [expr {($hhh)}] >= 0 } {
		  while { [expr {($hhh)}] >= 0 } {
		set oursuffix [string replace $oursuffix $hhh $hhh "%3F"]
		set hhh [ourstringfirst $oursuffix "?" 0]
		  }
		}
		
		
		
			    set iyy 0
			    set inv "n"
			    while { $iyy < [string length $oursuffix] } {
			       if { [string range $oursuffix $iyy $iyy] > "z" } {
			           set inv "y"
			       }
			       if { [string range $oursuffix $iyy $iyy] < " " } {
			           set inv "y"
			       }
			       set iyy [expr {$iyy + 1}]
			    }

		
		
		if { "$inv" != "y" } {
		#try {
		    set url "http://dictionary.reference.com/browse/$oursuffix"
#puts $url
		    #set r [http::geturl $url -binary 1]
        if {[catch {set r [http::geturl $url -binary 1]} err]} { return $err }
#set html [http::data $r]
        if {[catch {set html [http::data $r]} err]} { set html " " }
#::http::cleanup $r
        if {[catch {::http::cleanup $r} err]} { set html " " }
   # } catch {} {
    #  set $html " "
   # }
   } else {
     set $html " "
   }
#   set percent [expr {round((($percent + 5)))}]
#   if { [expr {$percent}] >= 100.0 } {
#     set percent 5
#   }
   	set atwo [ourstringfirst $html "</b></td></tr>" 0]
   	
   	# new below
   	if { [expr {($atwo)}] < 0 } {
   	set atwo [ourstringfirst $html "b> <br /><span" 0]
   	} else {
   #	puts "new atwo found"
	set atwo [expr {$atwo - 1}]
   	}
   	
	            set aone [ourstringfirst $html "</h2>" 0]
	            if { $atwo > 0 } {
	                set atwo [ourstringfirst [string range $html $atwo [expr {$atwo + 1000}]] "</b>" 0]
	              #  puts "atwo"
	                set zzz [string range $html  [expr {$atwo - $xLen - 1}] [expr {$atwo - 1}]]
	            
	                set btwo [ourstringfirst $zzz ">" 0]
	                ##print zzz[(btwo + 1):]
     #puts [string range $zzz [expr {$btwo + 1}] 1000]
	            } else {
	                if { $aone > 0 } {
	                    #atwo = html[aone:].find(".</a>")
	                set atwo [ourstringfirst [string range $html $aone  [expr {$aine + 1000}]] ".</a>" 0]
	                    if { $atwo < 0 } {
	                        #atwo = html[aone:].find("</a>")
	                set atwo [ourstringfirst [string range $html $aone  [expr {$aone + 1000}]] "</a>" 0]
	                    }
	                    if { $atwo > 0 } {
	                        set zzz [string range $html  [expr {$atwo - 61}] [expr {$atwo - 1}]]
	                        set btwo [ourstringfirst $zzz ">" 0]
     #puts [string range $zzz [expr {$btwo + 1}] 1000]
	                        
	                      
	                        ##print zzz[(btwo + 1):]
	                    }
	                }
	            }
	         }
     } else {
	      #  puts "atwo=$atwo"
	        set zzz [string range $html [expr {$atwo - $xLen - 1}] $atwo]
	        set bone [ourstringfirst $zzz ">" 0]
	        set btwo $bone
    # puts [string range $zzz [expr {$btwo + 1}] 1000]
	            
                #webbrowser.open_new('http://dictionary.reference.com/browse/' + zzz[(btwo + 1):].replace(" ", "+")) 
	        #html = urllib2.urlopen('http://dictionary.reference.com/browse/' + zzz[(btwo + 1):].replace(" ", "+")).read()
     }
     
     
  # puts [string range $zzz [expr {$btwo + 1}] 1000]

#   set percent [expr {round((($percent + 5)))}]
#   if { [expr {$percent}] >= 100.0 } {
#     set percent 5
#   }

 	    #zzz = zzz.replace("a","A").replace("b","B").replace("c","C").replace("d","D").replace("e","E").replace("f","F").replace("g","G").replace("h","H").replace("i","I").replace("j","J").replace("k","K").replace("l","L").replace("m","M").replace("n","N").replace("o","O").replace("p","P").replace("q","Q").replace("r","R").replace("s","S").replace("t","T").replace("u","U").replace("v","V").replace("w","W").replace("x","X").replace("y","Y").replace("z","Z")
         foreach xq "aA eE iI oO uU yY bB cC dD fF gG hH jJ kK lL mM nN pP qQ rR sS tT vV wW xX zZ" {
		set hhh [ourstringfirst $zzz [string range $xq 0 0] 0]
		if { [expr {($hhh)}] >= 0 } {
		  while { [expr {($hhh)}] >= 0 } {
		set zzz [string replace $zzz $hhh $hhh [string range $xq 1 1]]
		set hhh [ourstringfirst $zzz [string range $xq 0 0] 0]
		  }
		  }
		  }

        foreach qqqq "1" {

	    #if zzz[(btwo + 1):].find("A") > 0:
	    if { [ourstringfirst [string range $zzz [expr {$btwo + 1}] 1000] "A" 0] >= 0 } {
	        set invalid "n"
	    }
	    if { [ourstringfirst [string range $zzz [expr {$btwo + 1}] 1000] "E" 0] >= 0 } {
	        set invalid "n"
	    }
	    if { [ourstringfirst [string range $zzz [expr {$btwo + 1}] 1000] "I" 0] >= 0 } {
	        set invalid "n"
	    }
	    if { [ourstringfirst [string range $zzz [expr {$btwo + 1}] 1000] "O" 0] >= 0 } {
	        set invalid "n"
	    }
	    if { [ourstringfirst [string range $zzz [expr {$btwo + 1}] 1000] "U" 0] >= 0 } {
	        set invalid "n"
	    }
	    if { [ourstringfirst [string range $zzz [expr {$btwo + 1}] 1000] "Y" 0] >= 0 } {
	        set invalid "n"
	    }


	    if { [ourstringfirst [string range $zzz [expr {$btwo + 1}] 1000] "'S" 0] >= 0 } {
	        set invalid "y"
            }

	    if { [ourstringfirst [string range $zzz [expr {$btwo + 1}] 1000] "!" 0] >= 0 } {
	        set invalid "y"
            }


	    if { [ourstringfirst [string range $zzz [expr {$btwo + 1}] 1000] "." 0] >= 0 } {
	        set invalid "y"
	    }
	    if { [ourstringfirst [string range $zzz [expr {$btwo + 1}] 1000] "#" 0] >= 0 } {
	        set invalid "y"
	    }
	    if { [ourstringfirst [string range $zzz [expr {$btwo + 1}] 1000] "<" 0] >= 0 } {
	        set invalid "y"
	    }
	    if { [ourstringfirst [string range $zzz [expr {$btwo + 1}] 1000] "-" 0] >= 0 } {
	        set invalid "y"
	    }
	    if { [ourstringfirst [string range $zzz [expr {$btwo + 1}] 1000] ":" 0] >= 0 } {
	        set invalid "y"
	    }
	    if { [ourstringfirst [string range $zzz [expr {$btwo + 1}] 1000] ";" 0] >= 0 } {
	        set invalid "y"
	    }
	    if { [ourstringfirst [string range $zzz [expr {$btwo + 1}] 1000] "=" 0] >= 0 } {
	        set invalid "y"
	    }
	    if { [ourstringfirst [string range $zzz [expr {$btwo + 1}] 1000] "/" 0] >= 0 } {
	        set invalid "y"
	    }
	    if { [ourstringfirst [string range $zzz [expr {$btwo + 1}] 1000] "+" 0] >= 0 } {
	        set invalid "y"
	    }
	    if { [ourstringfirst [string range $zzz [expr {$btwo + 1}] 1000] "?" 0] >= 0 } {
	        set invalid "y"
	    }
	    if { [ourstringfirst [string range $zzz [expr {$btwo + 1}] 1000] "/" 0] >= 0 } {
	        set invalid "y"
	    }
	    if { [ourstringfirst [string range $zzz [expr {$btwo + 1}] 1000] "," 0] >= 0 } {
	        set invalid "y"
	    }
	    if { [ourstringfirst [string range $zzz [expr {$btwo + 1}] 1000] "_" 0] >= 0 } {
	        set invalid "y"
	    }
	    if { [ourstringfirst [string range $zzz [expr {$btwo + 1}] 1000] "&" 0] >= 0 } {
	        set invalid "y"
	    }
	    if { [ourstringfirst [string range $zzz [expr {$btwo + 1}] 1000] "%" 0] >= 0 } {
	        set invalid "y"
	    }
	    if { [ourstringfirst [string range $zzz [expr {$btwo + 1}] 1000] "\[" 0] >= 0 } {
	        set invalid "y"
	    }
	    if { [ourstringfirst [string range $zzz [expr {$btwo + 1}] 1000] "\{" 0] >= 0 } {
	        set invalid "y"
	    }
	    if { [ourstringfirst [string range $zzz [expr {$btwo + 1}] 1000] "(" 0] >= 0 } {
	        set invalid "y"
	    }
	    if { [ourstringfirst [string range $zzz [expr {$btwo + 1}] 1000] "'" 0] >= 0 } {
	        set invalid "y"
	    }
	    if { [ourstringfirst [string range $zzz [expr {$btwo + 1}] 1000] "0" 0] >= 0 } {
	        set invalid "y"
	    }
	    if { [ourstringfirst [string range $zzz [expr {$btwo + 1}] 1000] "1" 0] >= 0 } {
	        set invalid "y"
	    }
	    if { [ourstringfirst [string range $zzz [expr {$btwo + 1}] 1000] "2" 0] >= 0 } {
	        set invalid "y"
	    }
	    if { [ourstringfirst [string range $zzz [expr {$btwo + 1}] 1000] "3" 0] >= 0 } {
	        set invalid "y"
	    }
	    if { [ourstringfirst [string range $zzz [expr {$btwo + 1}] 1000] "4" 0] >= 0 } {
	        set invalid "y"
	    }
	    if { [ourstringfirst [string range $zzz [expr {$btwo + 1}] 1000] "5" 0] >= 0 } {
	        set invalid "y"
	    }
	    if { [ourstringfirst [string range $zzz [expr {$btwo + 1}] 1000] "6" 0] >= 0 } {
	        set invalid "y"
	    }
	    if { [ourstringfirst [string range $zzz [expr {$btwo + 1}] 1000] "7" 0] >= 0 } {
	        set invalid "y"
	    }
	    if { [ourstringfirst [string range $zzz [expr {$btwo + 1}] 1000] "8" 0] >= 0 } {
	        set invalid "y"
	    }
	    if { [ourstringfirst [string range $zzz [expr {$btwo + 1}] 1000] "9" 0] >= 0 } {
	        set invalid "y"
	    }
	    if { [ourstringfirst [string range $zzz [expr {$btwo + 1}] 1000] ". " 0] >= 0 } {
	        set invalid "y"
	    }
	    if { [ourstringfirst [string range $zzz [expr {$btwo + 1}] 1000] " OR " 0] >= 0 } {
	        set invalid "y"
	    }
	    if { [ourstringfirst [string range $zzz [expr {$btwo + 1}] 1000] " AND " 0] >= 0 } {
	        set invalid "y"
	    }


	    set iyy [expr {$btwo + 1}]
	    while { $iyy < [string length $zzz] } {
	       if { [string range $zzz $iyy $iyy] > "z" } {
	           set invalid "y"
	       }
	       if { [string range $zzz $iyy $iyy] < " " } {
	           set invalid "y"
	       }
	       set iyy [expr {$iyy + 1}]
	    }


	    if { [string range $zzz [expr {$btwo + 2}] [expr {$btwo + 2}]] == " " } {
	        if { [string range $zzz [expr {$btwo + 4}] [expr {$btwo + 4}]] == " " } {
	            set invalid "y"
	        }
	    }
	           


	##print zzz[(btwo + 1):]
	set _ourword [string range $zzz [expr {$btwo + 1}] 1000]
	#self._ourword = self._ourword.replace("a","A").replace("b","B").replace("c","C").replace("d","D").replace("e","E").replace("f","G").replace("g","G").replace("h","H").replace("i","I").replace("j","J").replace("k","K").replace("l","L").replace("m","M").replace("n","N").replace("o","O").replace("p","P").replace("q","Q").replace("r","R").replace("s","S").replace("t","T").replace("u","U").replace("v","V").replace("w","W").replace("x","X").replace("y","Y").replace("z","Z")

	#self._shownword = self._ourword.replace("A","?").replace("B","?").replace("C","?").replace("D","?").replace("E","?").replace("F","?").replace("G","?").replace("H","?").replace("I","?").replace("J","?").replace("K","?").replace("L","?").replace("M","?").replace("N","?").replace("O","?").replace("P","?").replace("Q","?").replace("R","?").replace("S","?").replace("T","?").replace("U","?").replace("V","?").replace("W","?").replace("X","?").replace("Y","?").replace("Z","?")
	set _shownword [string range $zzz [expr {$btwo + 1}] 1000]
         foreach xq "A E I O U Y B C D F G H J K L M N P Q R S T V W X Z" {
		set hhh [ourstringfirst $_shownword [string range $xq 0 0] 0]
		if { [expr {($hhh)}] >= 0 } {
		  while { [expr {($hhh)}] >= 0 } {
		set _shownword [string replace $_shownword $hhh $hhh "?"]
		set hhh [ourstringfirst $_shownword [string range $xq 0 0] 0]
		  }
		  }
		  }
		  
		set ok "y"  
		  
		  if { "$invalid" == "y" } {
#   set percent [expr {round((($percent + 5)))}]
#   if { [expr {$percent}] >= 100.0 } {
#     set percent 5
#   }
		     if { "$qqqq" == "1" } {
		     set bigl [expr {$xLen - 1}]
		     set xxwr ""
		     foreach xwr [split $html "><!@#$%^&*qwertyuiopasdfghjklzxcvbnm0987654321/?,;:'\[\]\{\}\(\)_+~`\r\n=-\\\" "] {
		     
		         if { [string length $xwr] > [expr {$bigl}] && [string length $xwr] == [expr {$xLen}] } {
		           set ok "y"
		           foreach nono "DOCTYPE PUBLIC PADDING AEDFCE REGEXP LYJCYFMP NEBEAE AHEMAHDJQB SUBHEAD CONTENT CAFCDE .XMLHTTP .TYPES. .TYPES FTXTXGKYVX AHIAQG PSIARIBIK OMLEAE XMLHTTP FFFFFF NQFEAE BORDER BOTTOM LEXICOF NASCAR $nogosuffix" {
		             if { "$xwr" == "$nono" } {
		               set ok "n"
		             }
		             if { "$xwr" == "DOCTYPE HTML PUBLIC" } {
		               set ok "n"
		             }
		           }
		           if { "$ok" == "y" } {
                                if { [ourstringfirst $html $xwr 0] < 0 } {
					set ok "n"
				}
                           }
		           if { "$ok" == "y" } {
		           	set bigl [string length $xwr]
		           	set btwo 0
		           	set zzz ">$xwr"
		           	#puts $zzz
		           	set nogosuffix "$nogosuffix $xwr"
		           	set xxwr $xwr
		           }
		         }
		     
		     }
		           if { "$ok" == "y" } {
		           	set nogosuffix "$nogosuffix $xxwr"
		           }
		     }
		  }

        }
     		  		  if { "$invalid" == "n" } {
#   set percent [expr {round((($percent + 5)))}]
#   if { [expr {$percent}] >= 100.0 } {
#     set percent 5
#   }
		set oursuffix [string range $zzz [expr {$btwo + 1}] 1000]
		set hhh [ourstringfirst $oursuffix " " 0]
		if { [expr {($hhh)}] >= 0 } {
		  while { [expr {($hhh)}] >= 0 } {
		set oursuffix [string replace $oursuffix $hhh $hhh "+"]
		set hhh [ourstringfirst $oursuffix " " 0]
		  }
		}
		set hhh [ourstringfirst $oursuffix "?" 0]
		if { [expr {($hhh)}] >= 0 } {
		  while { [expr {($hhh)}] >= 0 } {
		set oursuffix [string replace $oursuffix $hhh $hhh "%3F"]
		set hhh [ourstringfirst $oursuffix "?" 0]
		  }
		}
		
		    set url "http://acronyms.thefreedictionary.com/$oursuffix"
#puts "url2=$url"
		    #set r [http::geturl $url -binary 1]
        if {[catch {set r [http::geturl $url -binary 1]} err]} { return $err }
#set html [http::data $r]
        if {[catch {set html [http::data $r]} err]} { set html " " }
#::http::cleanup $r
        if {[catch {::http::cleanup $r]} err]} { set html " Word not found " }

if { [ourstringfirst $html "Word not found" 0] >= 0 && [ourstringfirst $html "Found in" 0] < 0 } {

   set invalid "y"
} else {
   set acr [ourstringfirst $html "<script>hc_dict" 0]
   if { $acr >= 0 } {
   
set qhuh [ourstringfirst [string range $html [expr {$acr - 61}] [expr {$acr - 1}]] "</div><script>hc_dict" 0]
   if { $qhuh < 0 } {
   	                        set zzz [string range $html  [expr {$acr - 61}] [expr {$acr - 1}]]
	                        set btwo [ourstringfirst $zzz "</b> " 0]
	                        if { $btwo >= 0 } {
	                          set btwo [expr {$btwo + 4}]
	                        } else {
	                        set btwo [ourstringfirst $zzz "</b>" 0]
	                        if { $btwo >= 0 } {
	                          set btwo [expr {$btwo + 3}]
	                        } 
	                        }
	      if { $btwo < 0 } {
	      set invalid "y"
	      } else {
      foreach xq "aA eE iI oO uU yY bB cC dD fF gG hH jJ kK lL mM nN pP qQ rR sS tT vV wW xX zZ" {
		set hhh [ourstringfirst $zzz [string range $xq 0 0] 0]
		if { [expr {($hhh)}] >= 0 } {
		  while { [expr {($hhh)}] >= 0 } {
		set zzz [string replace $zzz $hhh $hhh [string range $xq 1 1]]
		set hhh [ourstringfirst $zzz [string range $xq 0 0] 0]
		  }
		  }
		  }
#	puts "zzz is $zzz is better"
		  } else {
#	puts "zzz is $oursuffix is baad word"


   set acr [ourstringfirst $html "</td></tr><tr" 0]
   if { $acr >= 0 } {
   
set qhuh [ourstringfirst [string range $html [expr {$acr - 61}] [expr {$acr - 1}]] "</td></tr><tr" 0]
   if { $qhuh < 0 } {
   	                        set zzz [string range $html  [expr {$acr - 61}] [expr {$acr - 1}]]
	                        set btwo [ourstringfirst $zzz "</td><td>" 0]
	                        if { $btwo >= 0 } {
	                          set btwo [expr {$btwo + 8}]
	                        }
	                        
	      if { $btwo < 0 } {
	      set invalid "y"
	      } else {
     foreach xq "aA eE iI oO uU yY bB cC dD fF gG hH jJ kK lL mM nN pP qQ rR sS tT vV wW xX zZ" {
		set hhh [ourstringfirst $zzz [string range $xq 0 0] 0]
		if { [expr {($hhh)}] >= 0 } {
		  while { [expr {($hhh)}] >= 0 } {
		set zzz [string replace $zzz $hhh $hhh [string range $xq 1 1]]
		set hhh [ourstringfirst $zzz [string range $xq 0 0] 0]
		  }
		  }
		  }
#	puts "zzz is $zzz is better"
		  } else {
#	puts "zzz is $oursuffix is baad word"
	      set invalid "y"
		  }


		  }
	#} else {
	##puts "zzz is $zzz is normal word"
	}

	#} else {
	##puts "zzz is $zzz is normal word"
	}
	
	}
	
	
   }
}

if { "$invalid" == "y"  || [string length $_ourword] != $xLen } {
	$pb stop
return ""
} else {
#puts "here ..."
	$pb stop
	set achk "n"
	if { "$_ourword" != "" } {
	set achk [eval {checkWord $_ourword $xLen 3}]
	}
	if { "$achk" == "n" } {
	  return ""
	}
#puts " and here ..."
 categorizeword $_ourword
 set xxx [eval alttry $altHelp $xLen]
 if { "$xxx" != "" } {
   set corder($whichword) [eval {clueForWord $xxx "/span"}]
		  if { "$corder($whichword)" == " " } {
		    set corder($whichword) ""
		  } else {
   if { "$corder($whichword)" == "" } {
   set corder($whichword) [eval {clueForWord $xxx "br>"}]
   }
   }
   if { "$corder($whichword)" == "" } {
   set xxx [eval {altinventWord $xxx $whichword $xLen $altHelp $isdesperate}]
 #  puts "this has to be something=$xxx"
   }
   return $xxx
   
 } else {
   return ""
 }

}

}


#   set percent [expr {round((($percent + 5)))}]
#   if { [expr {$percent}] >= 100.0 } {
#     set percent 5
#   }
 }
	set shownword $_shownword
	
	#puts $_shownword
	#puts $_ourword

	##print self._ourword 
	##print self._shownword 
	
#	set percent 100
	
#	$pb stop
	
	return $talk
}

set squareval "Letter"
set difficulty "Easy"
set tclfile ""

set zchoice 6
set zlist(1) "raised"
set zlist(2) "sunken"
set zlist(3) "flat"
set zlist(4) "ridge"
set zlist(5) "groove"
set zlist(6) "solid"


#set zlist(1) "raised"
#set zlist(2) "sunken"
#set zlist(3) "raised"
#set zlist(4) "sunken"
#set zlist(5) "raised"
#set zlist(6) "sunken"


set nextz 1
set nextz [expr {round(rand()*[expr {$zchoice - 1}]) + 1}]   


set pchoice 38
set plist(1) "lightgreen"
set plist(2) "lightblue"
set plist(3) "yellow"
set plist(4) "pink"
set plist(5) "red"
set plist(6) "cyan"
set plist(7) "orange"
set plist(8) "firebrick"
set plist(9) "brown"
set plist(10) "blue"
set plist(11) "green"
set plist(12) "purple"


set plist(13) "grey"
set plist(14) "thistle"
set plist(15) "peru"
set plist(16) "tan"
set plist(17) "chocolate"
set plist(18) "gold"
set plist(19) "plum"
set plist(20) "violet"
set plist(21) "powderblue"
set plist(22) "aquamarine"
set plist(23) "magenta"
set plist(24) "navy"
set plist(25) "lawngreen"
set plist(26) "lightgrey"
set plist(27) "turquoise"

set plist(28) "tomato"
set plist(29) "royalblue"
set plist(30) "chartreuse"
set plist(31) "burlywood"
set plist(32) "coral"
set plist(33) "darkorange"
set plist(34) "darkgrey"

set plist(35) "sienna"
set plist(36) "steelblue"
set plist(37) "goldenrod"
set plist(38) "khaki"

set nextp 1
set nextp [expr {round(rand()*[expr {$pchoice - 1}]) + 1}]   


foreach i "$bigstr" {
  set hone($i) 0
  set jone($i) 0


  set eone($i) 0
  set xone($i) 0
  set yone($i) 0
  set sone($i) 0
  set wone($i) ""
  set vone($i) 0
  set cone($i) ""

  set varr($i) " "
  set arr($i) " "

  set zone($i) ""
  set pone($i) ""
  
  set taken($i) 0
  
  set tone($i) 0
  set bone($i) 0
  set lone($i) 0
  set rone($i) 0

}


set wsys [eval tk windowingsystem]

if { "$wsys" == "x11" || "$wsys" == "aqua" } {

set dir "/usr/bin"

} else {

set dir "."

}



##set w .puzzle
##catch {destroy $w}
##toplevel $w
set w [wm title . "Crossword"]
#wm conname $w "81-Crossword"
#positionWindow $w

#label $w.msg -font $font -wraplength 4i -justify left -text "A 15-puzzle appears below as a collection of buttons. Click on any of the pieces next to the space, and that piece will slide over the space. Continue this until the pieces are arranged in numerical order from upper-left to lower-right."
label $w.msg -wraplength 4i -justify left -text "Crossword"
pack $w.msg -side top

frame $w.buttons
pack $w.buttons -side bottom -fill x -pady 2m
ttk::button $w.buttons.dismiss -text "New Game" -command "NewGame"
pack $w.buttons.dismiss -side left -padx 5
ttk::combobox $w.buttons.newdiff -textvariable difficulty -width 15 -values [list Easy Moderate Difficult Impossible]
pack $w.buttons.newdiff -side left -padx 20 
ttk::button $w.buttons.code -text "Am I Correct?" -command "Check"
pack $w.buttons.dismiss $w.buttons.code -side left -expand 1
#ttk::button $w.buttons.value -text "Value" 
#ttk::combobox $w.buttons.ourvalue -textvariable squareval -width 3 -values [list 0 1 2 3 4 5 6 7 8 9]
#pack $w.buttons.value -side left -padx 5 -pady 6 
#pack $w.buttons.ourvalue -side left -padx 20


##scrollbar $w.s
#frame $w.frame -width 720 -height 528 -borderwidth 2 -relief sunken -bg red    
## [$w.s cget -troughcolor]
#pack $w.frame -side top -pady 1c -padx 1c
##destroy $w.s


proc ourstringfirst { thestring compstring startpos } {
  global osf
  set osf -1
  set qqww $startpos
  set found 0
  set offset [expr {[string length $compstring] - 1}]
  while { $found == 0 && $qqww < [string length $thestring] } {
    if { [string range $thestring $qqww $qqww] == [string range $compstring 0 0] } {
        set qqwwplus [expr {$qqww + $offset}]
        if { [string range $thestring $qqww $qqwwplus] == $compstring } {
            set osf $qqww
            set found 1
        }
    }
    set qqww [expr {$qqww + 1}]
  }
  return $osf
}

proc getArr {thissq} {
global cone arr sqsize xc

set j 0

if { [string length $arr([expr {$thissq - 0}])] < [string length $cone([expr {$thissq + 0}])] } {
#puts "first j=$arr([expr {$thissq - 0}])    a=$arr([expr {$thissq - 0}]) c=$cone([expr {$thissq + 0}])"
  set j [expr {$arr([expr {$thissq - 0}])}]
} else {
if { [string length $arr([expr {$thissq - 0}])] > [string length $cone([expr {$thissq + 0}])] } {
#puts "second j=[string range $arr([expr {$thissq - 0}]) [string length $cone([expr {$thissq + 0}])] 1000]  a=$arr([expr {$thissq - 0}]) c=$cone([expr {$thissq + 0}])"
  set j [expr {[string range $arr([expr {$thissq - 0}]) [string length $cone([expr {$thissq + 0}])] 1000]}]
} else {
return $arr([expr {$thissq - 0}])
}
}
#puts "j=$j"
return $j
}

proc setArr {thissq} {
global cone arr sqsize
set xxww [eval {getArr [expr {$thissq - 0}]}]
#puts "xxww=$xxww"
if { "$xxww" != " " &&  "$xxww" != "" } {
if { "$xxww" < "A" || "$xxww" > "Z" } {
set arr([expr {$thissq - 0}]) "$cone([expr {$thissq + 0}])A"
} else {
set arr([expr {$thissq - 0}]) "$cone([expr {$thissq + 0}])[string range $xxww 0 2]"
}
}

}

proc Crossword {ourmode jj} {
global xpos ypos
global w
global squareval sqsize
global arr cone xc
if { "$squareval" == "0" || "$squareval" == "Letter" } {
set xxww [eval {getArr [expr {$jj + 0}]}]
#puts "xxww=$xxww"
if { "$xxww" < "A" || "$xxww" > "Z" &&  "$xxww" != " " &&  "$xxww" != ""  } {
set arr($jj) "A"
} else {
#puts "sr=[string range    [eval {getArr [expr {$jj + 0}]}]    0 0] via [eval {getArr [expr {$jj + 0}]}] "
set qww [ourstringfirst $arr($jj) " ?" 0]
if { [expr {($qww)}] >= 0 } {
set qww [expr {$qww - 1}]
set arr($jj) [string range $arr($jj) $qww $qww]
} else {
set jjjar [eval {getArr [expr {$jj + 0}]}]

if { "$jjjar" >= "A" && "$jjjar" <= "Z" } {
set xc(91) "A"
for {set i 65} {$i <= 90} {set i [expr $i+1]} {
if { $xc($i) == $jjjar } {
set  arr($jj) $xc([expr {$i + 0}])
}
}
} else {

set jjar [string range    [eval {getArr [expr {$jj + 0}]}]    0 0]
set arr($jj) $xc([expr {64 + $jjar}])
}
}
set jjjar [eval {getArr [expr {$jj + 0}]}]

if { "$jjjar" >= "A" && "$jjjar" <= "Z" } {
set xc(91) "A"
for {set i 65} {$i <= 90} {set i [expr $i+1]} {
if { $xc($i) == $jjjar } {
set  arr($jj) $xc([expr {$i + 1}])
}
}
} else {

set jjar [expr {((    [eval {getArr [expr {$jj + 0}]}]     + 1) % 26)}]
set arr($jj) $xc([expr {64 + $jjar}])
}

}
} else {
set arr($jj) $squareval
}
if { "$arr($jj)" < "A" &&  "$arr($jj)" != " " &&  "$arr($jj)" != "" } {
set arr($jj) "A"
}

setArr [expr {$jj}]

}

proc Check {} {
global varr
global arr
global mode
global xorder cone sqsize


for {set i 0} {$i < $mode} {set i [expr $i+1]} {
set qww [ourstringfirst $arr([expr {$i + 1}]) " ?" 0]
if { [expr {($qww)}] >= 0 } {
set qww [expr {$qww - 1}]
#puts "arwas=$arr([expr {$i + 1}])"
set arr([expr {$i + 1}]) [string range $arr([expr {$i + 1}]) $qww $qww]
#puts "aris=$arr([expr {$i + 1}])"
}
}

for {set i 0} {$i < $mode} {set i [expr $i+1]} {
#set num [lindex $order $i]
set num [expr {$i + 1}]
if { "$arr([expr {$i + 1}])" != "$cone([expr {$i + 1}])" } {
  if { "$varr([expr {$i + 1}])" != [eval {getArr [expr {$i + 1}]}] } {
    if { "$arr([expr {$i + 1}])" != "" } {
set qww [ourstringfirst $arr([expr {$i + 1}]) " ?" 0]
if { [expr {($qww)}] < 0 } {
      set arr([expr {$i + 1}]) "[eval {getArr [expr {$i + 1}]}] ?"
}
      set arr([expr {$i + 1}]) [string range [eval {getArr [expr {$i + 1}]}] 0 2]
# puts "here ar is $arr([expr {$i + 1}])"
      setArr [expr {$i + 1}]
    }
  }
  }
}
}

proc NewGame {} {
        global wsys

        global dir


   global tclfile
   global mode
   global difficulty




        set progname "Crossword"

        set prog "$dir/$progname"

        

    if { "$wsys" == "x11" || "$wsys" == "aqua" } {

  	exec sh Crossword.sh $mode $difficulty &; exit

  	} else {

  	exec $prog $mode $difficulty &; exit

  	}
}

proc drawThings {oursq} {
  global eone xone yone taken sqsize arr wone vone sone cone tone bone lone rone zone pone
  global zlist plist 
  global nextz nextp
  
  set zone($oursq) $zlist($nextz)
  
  set pone($oursq) $plist($nextp)

}

proc isItAllowed {ourindex tot} {
  global eone xone yone taken sqsize varr arr wone vone sone cone tone bone lone rone zone zchoice nextz zlist pone nextp plist pchoice difficulty hone jone

  #puts "trying ... $eone($ourindex) for $tot of $xone($ourindex) and $yone($ourindex)"
set taken([expr {$sqsize * $sqsize + 1}]) 999

set taken([expr {$sqsize * $sqsize + 2}]) 999

set taken([expr {$sqsize * $sqsize + 3}]) 999

set taken([expr {$sqsize * $sqsize + 4}]) 999

set taken([expr {$sqsize * $sqsize + 5}]) 999

set taken([expr {$sqsize * $sqsize + 6}]) 999

set taken([expr {$sqsize * $sqsize + 7}]) 999

set taken([expr {$sqsize * $sqsize + 8}]) 999

set taken([expr {$sqsize * $sqsize + 9}]) 999

set taken([expr {$sqsize * $sqsize + 10}]) 999

set taken([expr {$sqsize * $sqsize + 11}]) 999

set taken([expr {$sqsize * $sqsize + 12}]) 999

set taken([expr {$sqsize * $sqsize + 13}]) 999

set taken([expr {$sqsize * $sqsize + 14}]) 999

  set ok 0
  
  set four 4

  set startsq 1
  set found 0
  set snake " "
  
  set cmultiply "multiply"
  set cdivide "divide"
  
  if { "$difficulty" == "Easy" } {
    set cmultiply "add"
    set cdivide "minus"
  }

  if { "$difficulty" == "Difficult" || "$difficulty" == "Impossible" } {
    set four 5
  }

  set prevsq 0
  set labelsq 0
  set lastinlist 0
  set add 0
  set minus 0
  set multiply 0
  set divide 0.0
  set idivide 0
  set candodivide 1
  
  set goes 0

  set three 3
  
  if { "$eone($ourindex)" == "1" } {
    set candodivide 0
    set three 1
  }
  
  while { [expr {$startsq}] <= [expr {$sqsize * $sqsize}] && "$found" == "0" && [expr {$goes}] < [expr {$eone($ourindex)}] } {
    if { "$taken($startsq)"   == "0" } {
    #puts "candidate is $startsq"
 
  set prevsq 0
  set labelsq 0
  set lastinlist 0
  set add 0
  set minus 0
  set multiply 0
  set divide 0.0
  set idivide 0
  set candodivide 1
  
  if { "$eone($ourindex)" == "1" } {
    set candodivide 0
    set three 1
  }

      set snake " "
       set found $startsq
       set xstep 1
       set ystep 1
       set yplus 0
       
       if { [expr {$xstep}] <= [expr {$xone($ourindex)}] && [expr {$xone($ourindex)}] > 0  } {
         while { "$found" != "0" && [expr {$xstep}] <= [expr {$xone($ourindex)}] } {
         #puts "this while $xstep $startsq"
           if { "$taken($startsq)"   != "0" } {
             set found 0
             #puts "bad 0"
           } else {
           
       set goes [expr {$goes + 1}]
             #puts "startsq=$startsq varr([expr {$startsq}])=$varr([expr {$startsq}]) arr([expr {$startsq}])=$arr([expr {$startsq}]) $snake"
             set add [expr {$add + $varr([expr {$startsq}])}]
             
             if { "$multiply" == "0" } {
               set multiply [expr {$varr([expr {$startsq}])}]
             } else {
               set multiply [expr {$multiply * $varr([expr {$startsq}])}]
             }
             
             if { "$minus" == "0" && "$three" == "3" } {
               set minus [expr {$varr([expr {$startsq}])}]
             } else {
             
             
               if { [expr {$eone($ourindex)}] == 2 && [expr {$minus}] < [expr {$varr([expr {$startsq}])}] } {
             
               set minus [expr {$varr([expr {$startsq}]) - $minus}]
               
               } else {
             
               set minus [expr {$minus - $varr([expr {$startsq}])}]
               if { [expr {($minus)}] <= 0 && "$three" != "1" } {
                 set three 2
                 set candodivide 0
               }
               
               }
             
             }
           
           
             if { "$candodivide" != "0" } {
               if { "$divide" == "0" } {
                 set divide [expr {round($varr([expr {$startsq}]))}]
                 set idivide [expr {$varr([expr {$startsq}])}]
               } else {
                 if { [expr {$eone($ourindex)}] == 2 && [expr {$idivide}] < [expr {$varr([expr {$startsq}])}] } {

                   if { [expr {$varr([expr {$startsq}]) % $idivide}] > 0 } {
                     set candodivide 0
                   } else {
                     set divide [expr {round($varr([expr {$startsq}])) / $divide}]
                     set idivide [expr {$varr([expr {$startsq}]) / $idivide}]
                   }
                 
                 } else {

                 if { [expr {round($varr([expr {$startsq}]))}] > [expr {$divide}] } {
                   set candodivide 0
                 } else {
                   #puts "varr([expr {$startsq}])=..."
                   #puts "$varr([expr {$startsq}])"
                   if { [expr {$idivide % $varr([expr {$startsq}])}] > 0 } {
                     set candodivide 0
                   } else {
                     set divide [expr {$divide / round($varr([expr {$startsq}]))}]
                     set idivide [expr {$idivide / $varr([expr {$startsq}])}]
                   }
                 }
                 
                 
                 }
                 
               }
             }
           
             if { "$labelsq" == "0" } {
               set prevsq [expr {$startsq - 1}]
               set labelsq "$startsq"
             }
           
             set lastinlist [expr {$startsq}]
             set lastsq [expr {$startsq + 1}]
             set snake "$snake $startsq"
             set found $startsq
             set ystep 2
             set yplus [expr {$sqsize - 1}]
           }
           set xstep [expr {$xstep + 1}]
           set startsq [expr {$startsq + 1}]
           
           #if { "$found" != "0" && [expr {$xstep}] <= [expr {$xone($ourindex)}] && [expr {$startsq}] > [expr {$sqsize * $sqsize}] } {
           #  set found 0
           #}
           
           if { "$found" != "0" && [expr {$xstep}] <= [expr {$xone($ourindex)}] && [expr {$startsq}] <= [expr {$sqsize * $sqsize}] } {
           if { [expr {$startsq % $sqsize}] == 1 } {
             set found 0
             #puts "bad 1"
           }
           } else {
             if { [expr {$xstep}] <= [expr {$xone($ourindex)}] } {
               set found 0
             #puts "bad 2"
             } 
           }
           
         }
         
         
         
       }
       
       if { [expr {$ystep}] <= [expr {$yone($ourindex)}] && "$found" != "0" && [expr {$yone($ourindex)}] > 0 } {
         if { [expr {$startsq + $yplus}] > [expr {$sqsize * $sqsize}] } {
           set found 0
         } else {
           set startsq [expr {$startsq + $yplus}]
         }
         while { "$found" != "0" && [expr {$ystep}] <= [expr {$yone($ourindex)}] } {
         #puts "that while $ystep vs $startsq"
           set yplus $sqsize
           if { "$taken($startsq)" != "0" } {
             set found 0
             #puts "bad 3"
           } else {
           
       set goes [expr {$goes + 1}]
             #puts "Startsq=$startsq varr([expr {$startsq}])=$varr([expr {$startsq}]) arr([expr {$startsq}])=$arr([expr {$startsq}]) $snake"
             set add [expr {$add + $varr([expr {$startsq}])}]
             
             if { "$multiply" == "0" } {
               set multiply [expr {$varr([expr {$startsq}])}]
             } else {
               set multiply [expr {$multiply * $varr([expr {$startsq}])}]
             }
             
             if { "$minus" == "0" && "$three" == "3" } {
               set minus [expr {$varr([expr {$startsq}])}]
             } else {
             
             
               if { [expr {$eone($ourindex)}] == 2 && [expr {$minus}] < [expr {$varr([expr {$startsq}])}] } {
             
               set minus [expr {$varr([expr {$startsq}]) - $minus}]
               
               } else {
             
               set minus [expr {$minus - $varr([expr {$startsq}])}]
               if { [expr {($minus)}] <= 0 && "$three" != "1" } {
                 set three 2
                 set candodivide 0
               }
               
               }
             
             }
           
           
             if { "$candodivide" != "0" } {
               if { "$divide" == "0" } {
                 set divide [expr {round($varr([expr {$startsq}]))}]
                 set idivide [expr {$varr([expr {$startsq}])}]
               } else {
                 if { [expr {$eone($ourindex)}] == 2 && [expr {$idivide}] < [expr {$varr([expr {$startsq}])}] } {

                   if { [expr {$varr([expr {$startsq}]) % $idivide}] > 0 } {
                     set candodivide 0
                   } else {
                     set divide [expr {round($varr([expr {$startsq}])) / $divide}]
                     set idivide [expr {$varr([expr {$startsq}]) / $idivide}]
                   }
                 
                 } else {

                 if { [expr {round($varr([expr {$startsq}]))}] > [expr {$divide}] } {
                   set candodivide 0
                 } else {
                   #puts "varr([expr {$startsq}])=..."
                   #puts "$varr([expr {$startsq}])"
                   if { [expr {$idivide % $varr([expr {$startsq}])}] > 0 } {
                     set candodivide 0
                   } else {
                     set divide [expr {$divide / round($varr([expr {$startsq}]))}]
                     set idivide [expr {$idivide / $varr([expr {$startsq}])}]
                   }
                 }
                 
                 
                 }
                 
               }
             }

             if { "$labelsq" == "0" } {
               set prevsq [expr {$startsq - $sqsize}]
               set labelsq "$startsq"
             }
             
             set lastinlist [expr {$startsq}]
             set lastsq [expr {$startsq + $sqsize}]
             set snake "$snake $startsq"
             set found $startsq
           }
           set ystep [expr {$ystep + 1}]
           set startsq [expr {$startsq + $sqsize}]
           
           if { "$found" != "0" && [expr {$ystep}] <= [expr {$yone($ourindex)}] && [expr {$startsq}] > [expr {$sqsize * $sqsize}] } {
             set found 0
             #puts "bad 5"
           }
         }
         
         
         
       }
    
       
    }
    
    set startsq [expr {$startsq + 1}]
    #if { "$found" != "0" && [expr {$startsq}] > [expr {$sqsize * $sqsize}] } {
         ##set found 0
             #puts "bad 4"
    #}
    
    
    
  }


  if { "$found" != "0" } {
      set ok 1
      
      set way [expr {$candodivide + round(rand()*[expr {$three - 1}])}]   
      
      #puts "way=$way three=$three candodivide=$candodivide  eone=$eone($ourindex)"
      
      set awone 0
      
      if { [string length $multiply] >= [expr {$four}] } {
        set cmultiply "add"
      }
      
      set waymodes "add $cmultiply minus $cdivide" 
      
      if { "$candodivide" == "1" } {
          set waymodes "$cdivide $cdivide $cdivide $cdivide" 
      } else {
        if { "$three" == "3" } {
          set waymodes "minus minus minus minus" 
        } 
      }
      
      foreach thisway "$waymodes" {
        if { "$way" == "$awone" } {
          set wone($labelsq) $thisway
          if { "$thisway" == "add" } {
            if { "$three" == "1" } {
              set vone($labelsq) "cage"
              set cone($labelsq) "$add"
              set tone($labelsq) 1
              set bone($labelsq) 1
              set rone($labelsq) 1
              set lone($labelsq) 1
              
              set arr([expr {$labelsq}]) $cone($labelsq)
            } else {
              set vone($labelsq) $add
              set cone($labelsq) "$add + "
              
              set arr([expr {$labelsq}]) $cone($labelsq)
            }
          } else {
          if { "$thisway" == "minus" } {
            set vone($labelsq) $minus
            set cone($labelsq) "$minus - "
              
            set arr([expr {$labelsq}]) $cone($labelsq)
          } else {
          if { "$thisway" == "multiply" } {
            set vone($labelsq) $multiply
            set cone($labelsq) "$multiply * "
              
            set arr([expr {$labelsq}]) $cone($labelsq)
          } else {
          if { "$thisway" == "divide" } {
            set vone($labelsq) $idivide
            set cone($labelsq) "$idivide / "
              
            set arr([expr {$labelsq}]) $cone($labelsq)
         # } else {
            #puts "Beats me"
          }
          }
          }
          }
          }
                set awone [expr {$awone + 1}]
      }
      
      
      set firstone 1
      set lastone 0
      
      #puts "snake=$snake ... $three $eone($ourindex) for $tot of $xone($ourindex) and $yone($ourindex) ... $cone($labelsq)"
      
      if { "$snake" == " " } {
        set ok 0
        return $ok
      }
      
      foreach xhuh "$snake" {  
        if { "$xhuh" == "$lastinlist" } {
          set lastone 1
        }
        set nextsq $lastsq
        set goforit 0
        foreach zhuh "$snake" {
           if { "$goforit" != "0" } {
             set nextsq $zhuh
           }
           if { "$zhuh" == "$xhuh" } {
             set goforit 1
           } else {
             set goforit 0
           }
        }
        set taken($xhuh) 1
        set sone($xhuh) $labelsq
        
        
        if { [expr {$xhuh - $prevsq}] == 1 && [expr {$nextsq - $xhuh}] == 1 } {
            set lone($xhuh) $firstone
            set tone($xhuh) 1
            set bone($xhuh) 1
            set rone($xhuh) $lastone
            set hone($xhuh) -2
        } else {
          if { [expr {$xhuh - $prevsq}] == $sqsize && [expr {$nextsq - $xhuh}] == $sqsize } {
            set tone($xhuh) $firstone
            set lone($xhuh) 1
            set rone($xhuh) 1
            set bone($xhuh) $lastone
            set jone($xhuh) -2
          } else {
          if { [expr {$xhuh - $prevsq}] == 1 && [expr {$nextsq - $xhuh}] == $sqsize } {
            set tone($xhuh) 1
            set rone($xhuh) 1
          } else {
          if { [expr {$xhuh - $prevsq}] == $sqsize && [expr {$nextsq - $xhuh}] == 1 } {
            set bone($xhuh) 1
            set lone($xhuh) 1
          #} else {
            #puts "Beats me again xhuh=$xhuh prevsq=$prevsq nextsq=$nextsq sqsize=$sqsize firstone=$firstone lastone=$lastone eone($xhuh)=$eone($xhuh)"
          }
          }
          }
        }
        
        
        set prevsq $xhuh
        set firstone 0
        
        #puts "set square $xhuh for $tot of $xone($ourindex) and $yone($ourindex) at end $xstep $ystep with $cone($xhuh)"
        drawThings $xhuh
      }
      
      set nextz [expr {(($nextz + 1) % $zchoice) + 1}]
      set nextp [expr {(($nextp + 1) % $pchoice) + 1}]
  }

  
  return $ok
}

proc setEone {} {
  global eone xone yone taken sqsize difficulty

  set total 0
  set eoneindex 1
  
  set four 4

  if { "$difficulty" == "Easy" } {
    set four 3
  }
  if { "$difficulty" == "Difficult" } {
    set four 5
  }
  if { "$difficulty" == "Impossible" } {
    set four 7
  }
  
  while { [expr {$total}] < [expr {$sqsize * $sqsize}] } {
   set huh 0
   while { "$huh" == "0" } {
  
    set cotf [expr {1 + round(rand() * [expr {$four}])}]   
    
    if { [expr {$total + $cotf}] > [expr {$sqsize * $sqsize}] } {
      set cotf [expr {[expr {$sqsize * $sqsize}] - $total}]
    } 
    set total [expr {$total + $cotf}] 
    set eone($eoneindex) $cotf
    
    if { [expr {$cotf}] <= 2 } {
      if { "$cotf" == "1" } {
        set xone($eoneindex) 1
      } else {
        if { [expr {1+round(rand()*1)}] == 1 } {
         set xone($eoneindex) 2
        } else {
         set yone($eoneindex) 2
        }
      }
    } else {
      set xone($eoneindex) [expr {0 + round(rand() * $cotf)}]
      if { [expr {$xone($eoneindex)}] <= 1 } {
         set xone($eoneindex) 0
         set yone($eoneindex) $cotf
      } else {
        set yone($eoneindex) [expr {($cotf + 1) - $xone($eoneindex)}]
      }
    }
    
    set huh [eval isItAllowed $eoneindex $total]
    
    if { "$huh" == "0" } {
      set total [expr {$total - $cotf}] 
      set xone($eoneindex) 0
      set yone($eoneindex) 0
    }
   }
   
   set eoneindex [expr {$eoneindex + 1}]
  }

}


proc Create {} {
global xorder
global varr
global arr
global mode
global difficulty
global onoff
global w sqsize

ttk::button $w.buttons.value -text "Value" 
  
  if { "$difficulty" == "Easy" } {
    #set cmultiply "add"
    #set cdivide "minus"
    set sqsize 6
    set mode [expr {$sqsize * $sqsize}]
ttk::combobox $w.buttons.ourvalue -textvariable squareval -width 3 -values [list 0 1 2 3 4 5 6]
  } else {

ttk::combobox $w.buttons.ourvalue -textvariable squareval -width 3 -values [list 0 1 2 3 4 5 6 7 8 9]
}
pack $w.buttons.value -side left -padx 5 -pady 6 
pack $w.buttons.ourvalue -side left -padx 20


#scrollbar $w.s
frame $w.frame -width 710 -height 520 -borderwidth 2 -relief sunken -bg red    
# [$w.s cget -troughcolor]
pack $w.frame -side top -pady 1c -padx 1c
#destroy $w.s


focus -force $w
tk_focusFollowsMouse

set k [expr {$sqsize + 1}]
while { $k == [expr {$sqsize + 1}] } {
set k [expr {((round(rand() * $sqsize) + 1))}]
}
set xorder(1) $k
set row 1
set col 1
  # puts "Please wait ..."

set bad 0
set ok "n"
set ir 90
set ir1 [expr {$ir + 1}]
   #puts "Please wait2 ..."

set offset -5
if { "$difficulty" == "Easy" } {
  set offset -4
} elseif { "$difficulty" == "Moderate" } {
  set offset -5
} elseif { "$difficulty" == "Difficult" } {
  set offset -6
} elseif { "$difficulty" == "Impossible" } {
  set offset -7
}

   #puts "Please wait3 ..."

for {set jjj 1} {$jjj <= [expr {$mode / $sqsize}]} {set jjj [expr $jjj+1]} {
   #puts "Please wait3 ... $jjj"
 set noshowcount($jjj) $offset
 set showcount($jjj) 0
 for {set jjjj 1} {$jjjj <= [expr {$sqsize}]} {set jjjj [expr $jjjj+1]} {
   set onoff([expr {($jjj - 1) * $sqsize + $jjjj}]) 1
 } 
}

 for {set j 2} {$j <= $mode} {set j [expr $j+1]} {
   set row [expr {($j - 1) / $sqsize}]
   set col [expr {($j - 1) % $sqsize}]
   set thesquare [expr {($row / 3) * 3 + ($col / 3) + 1}]
   if { "$j" == "2" } {
       set onoff(1) 1
       if { [expr {($offset) + round(rand() * $sqsize) + 1}] >= 0 } {
         set showcount(1) [expr {$showcount(1) + 1}]     
       } else {
         set onoff(1) 0
         set noshowcount(1) [expr {($noshowcount(1)) + 1}]     
       }
   }

   if { [expr {($noshowcount($thesquare))}] >= 0 } {
     set onoff($j) 1
     set showcount($thesquare) [expr {$showcount($thesquare) + 1}]
   } elseif { [expr {($noshowcount($thesquare)) + $sqsize - $showcount($thesquare)}] <= 0 } { 
     set onoff($j) 0
     set noshowcount($thesquare) [expr {($noshowcount($thesquare)) + 1}]
   } elseif { [expr {($offset) + round(rand() * $sqsize) + 1}] >= 0 } {
     set onoff($j) 1
     set showcount($thesquare) [expr {$showcount($thesquare) + 1}]     
   } else {
     set onoff($j) 0
     set noshowcount($thesquare) [expr {($noshowcount($thesquare)) + 1}]     
   }
 }
 
   #puts "Please wait 4..."
   
	set three [expr {$sqsize}]
	if { [expr {$sqsize}] >= 9 || 99 == 99 } {
   set three [expr {$sqsize / 3}]
   }

while { "$ok" == "n" } {
 set bad 0

 for {set j 2} {$j <= $mode} {set j [expr $j+1]} {
   set found 1
   set row [expr {($j - 1) / $sqsize}]
   set col [expr {($j - 1) % $sqsize}]
   set thesquare [expr {($row / $three) * $three + ($col / $three) + 1}]
  # puts "Please wait5 ..."
   
   
   while { "$found" == "1" } {
		set k [expr {$sqsize + 1}]
		while { $k == [expr {$sqsize + 1}] } {
			set k [expr {((round(rand() * $sqsize) + 1))}]
		}
   		set found 0
  		 if { [expr {$bad}] > $ir } {
   		   set found 1
  		 }
   
 	     if { $found == 0 } {
   			for {set jj 1} {$jj < $j} {set jj [expr $jj+1]} {
 		      set nrow [expr {($jj - 1) / $sqsize}]
 		      set ncol [expr {($jj - 1) % $sqsize}]
 		      #puts "jj=$jj j=$j"
 		      set relevant 0
 		      if { [expr {($j - 1) / $sqsize}] == [expr {($jj - 1) / $sqsize}] } {
		           set relevant 1
		       } elseif { [expr {($j - 1) % $sqsize}] == [expr {($jj - 1) % $sqsize}] } {
		           set relevant 1
		       } elseif { [expr {$row / $three}] == [expr {$nrow / $three}] && [expr {$col / $three}] == [expr {$ncol / $three}] } {
		           set relevant 1
		       }
		       if { "$relevant" == "1" } {
		       	   if { "$k" == "$xorder($jj)" || [expr {$k}] > [expr {$mode}]} {
		           	 set found 1
		             set bad [expr {$bad + 1}]
		             if { $bad == $ir1 } {
		             	#puts "$bad xorder($j) try for $k at $row and $col stopped because same as xorder($jj)=$xorder($jj) at $nrow $ncol"
					 }
	      	       } 
       		   } 
   			}
   		 } else {
   		 	set found 0
   		 }
   }
   set xorder($j) $k
   if { "$j" == "$mode" && $bad < $ir } {
      set ok "y"
   } elseif { $bad <= $ir } {
      set bad 0
   }
 }
}
#puts " ... thank you for waiting."
Display
}

proc Display {} {
global xorder
global varr
global arr
global mode
global onoff
global w
global zone
global cone vone pone hone jone sqsize


set r "raised"
if { "$mode" == "81" || 1 == 1 } {
#set order {3 1 6 2 5 7 15 13 4 11 8 9 14 10 12}
for {set i 0} {$i < $mode} {set i [expr $i+1]} {
#set num [lindex $order $i]
set num $xorder([expr {$i + 1}])
#puts "num=$num"
set varr([expr {$i + 1}]) [expr {$num}]
}

#puts "here"
setEone
#puts "out of here"


for {set i 0} {$i < $mode} {set i [expr $i+1]} {
#set num [lindex $order $i]
set num $xorder([expr {$i + 1}])
#puts "num=$num"
#puts "varr($num)=$varr($num)"
##set arr([expr {$i + 1}]) "$num"
   set row [expr {($i) / $sqsize}]
   set col [expr {($i) % $sqsize}]
set k [expr {((round(rand() * 16) + 1))}]
#if { [expr {$onoff([expr {$i + 1}])}] == 0 } {
#  set arr([expr {$i + 1}]) ""
#}
set xpos($num) [expr ($i % $sqsize)*(1.0 / $sqsize)]
set ypos($num) [expr ($i / $sqsize)*(1.0 / $sqsize)]
#puts "i=$i num=$num varr([expr {$i + 1}]))=$varr([expr {$i + 1}]) arr([expr {$i + 1}]))=$arr([expr {$i + 1}]) cone([expr {$i + 1}]))=$cone([expr {$i + 1}])"



if { $arr([expr {$i + 1}]) == "" } {
button $w.frame.[expr {$i + 1}] -relief $zone([expr {$i + 1}]) -bg $pone([expr {$i + 1}]) -textvariable arr([expr {$i + 1}]) -highlightthickness 0 -command "KenKen $mode [expr {$i + 1}]"
place $w.frame.[expr {$i + 1}] -relx $xpos($num) -rely $ypos($num) -relwidth [expr {1.0 / $sqsize}] -relheight [expr {1.0 / $sqsize}]  -height $hone([expr {$i + 1}]) -width $jone([expr {$i + 1}])
} else {
if { "$vone([expr {$i + 1}])" == "cage" } {
button $w.frame.[expr {$i + 1}] -state disabled -bg beige -relief $zone([expr {$i + 1}])  -textvariable arr([expr {$i + 1}]) -highlightthickness 0 -command "KenKen $mode [expr {$i + 1}]"
} else {
button $w.frame.[expr {$i + 1}] -relief $zone([expr {$i + 1}]) -bg $pone([expr {$i + 1}]) -textvariable arr([expr {$i + 1}]) -highlightthickness 0 -command "KenKen $mode [expr {$i + 1}]"
}
place $w.frame.[expr {$i + 1}] -relx $xpos($num) -rely $ypos($num) -relwidth [expr {1.0 / $sqsize}]  -relheight [expr {1.0 / $sqsize}]  -height $hone([expr {$i + 1}]) -width $jone([expr {$i + 1}])
}

if { [expr {($i + 1) % 3}] == 0 && ([expr {($i + 1) % $sqsize}] != 0 || [expr {($i + 1) % 27}] == 0) } {
   if { "$r" == "raised" } {
       set r "sunken"
   } else {
       set r "raised"
   }
}


}
set xpos(space) .25
set ypos(space) .25
} elseif { "$mode" == "9" } {
#set order {3 1 6 2 5 7 15 13 4 11 8 9 14 10 12}
for {set i 0} {$i < $mode} {set i [expr $i+1]} {
#set num [lindex $order $i]
set num $xorder([expr {$i + 1}])
#puts "num=$num"
set varr($num) [expr {$num}]
#puts "varr($num)=$varr($num)"
set arr($num) "$num"
set k [expr {((round(rand() * 3) + 1))}]
if { "$k" != "2" } {
  set arr($num) ""
}
set xpos($num) [expr ($i%3)*0.33]
set ypos($num) [expr ($i/3)*0.33]
button $w.frame.$num -relief raised -textvariable arr($num) -highlightthickness 0 -command "KenKen $mode $num"
place $w.frame.$num -relx $xpos($num) -rely $ypos($num) -relwidth .33 -relheight .33
}
set xpos(space) .75
set ypos(space) .75

}





}
  	
set percent 0

inventAllWords