code guessing, round #20 (completed)

                                             load(([[f
                                            unction@I(s
                         ,p,v)re           turn@s:sub(#"
                   -",p-#"$")..v..s:su     b(p+#"#")end;
                function@M(b,p)local@v,c=   -#"#",-#"$_
             ";for@i=#"#",#'_$(.)(.)$'do@if@ b:sub(i,i
           )=="."then@b=I(b,i,p);l      ocal@
          a=-m(b,p=="x"and"o"or"          x")if
         @a>c@then@v,c=i,a@end@b           =I(b,
        i,".")end@end@return@v,c          @end;fu
        nction@m(S,p)local@w,A,B,C       ='.',{1,
       4,7,1,2,3,1,3},{2,5,8,4,5,6,5,5},{3,6,9,7,8
       ,9,9,7};for@i=#"#",#'#&*!__[]'@do@local@a,b
       ,c=S:sub(A[i],A[i]),S:sub(B[i],B[i]),S:sub(
       C[i],C[i]);if@a==b@and@a==c@and@a~="."then@
        w=a@end@end@if@w~='.'then@return@w==p@and
        #"."or-#"."end@return({M(S,p)})[#"[]"]end
         ;function@entry(s)local@b=s:gsub("%\n",
          '');return@I(b,M(b,'x'),"x")end]]):--
            gsub("[ \n]",""):gsub("@"," "))()
              --[=[[_](#_-_[_._]/_[_._]).._
                [_[#_]_)]+#_/_[_._],_[_[_
                    [#_]](#_)]+#_-]=]

module Win (precompute, form, pre) where

import Data.Foldable (maximumBy)
import Data.Function (on)
import Data.List (nub)
import Data.Maybe (fromMaybe)
import Language.Haskell.TH

won :: Char -> String -> Bool
won p [north_west, north, north_east, '\n', west, up, east, '\n', south_west, south, south_east] = line p [north_west, north, north_east, '\n', west, up, east, '\n', south_west, south, south_east] || line p [south_west, west, north_west, '\n', south, up, north, '\n', south_east, east, north_east]
  where
    line p (_ : _ : _ : '\n' : xs) | line p xs = True
    line p ('x' : 'x' : 'x' : _) | p == 'x' = True
    line p ('o' : 'o' : 'o' : _) | p == 'o' = True
    line p (_ : _ : 'x' : '\n' : _ : 'x' : _ : '\n' : 'x' : _) | p == 'x' = True
    line p (_ : _ : 'o' : '\n' : _ : 'o' : _ : '\n' : 'o' : _) | p == 'o' = True
    line _ _ = False

winning :: String -> Maybe (Maybe Char)
winning xs
  | won 'x' xs = Just (Just 'x')
  | won 'o' xs = Just (Just 'o')
  | '.' `notElem` xs = Just Nothing
winning _ = Nothing

turns :: Char -> String -> [String]
turns p xs = go p [] ([], xs)
  where
    go _ options (_, []) = map dezip options
      where
        dezip (hs, ts) = reverse hs ++ ts
    go p options (hs, h : ts) = go p (flex h options) (h : hs, ts)
      where
        flex '.' = ((hs, p : ts) :)
        flex c = id

form :: [String]
form = nub $ blank : concat [turns 'o' blank, turns 'x' blank >>= turns 'o', turns 'o' blank >>= turns 'x' >>= turns 'o']
  where
    blank = "...\n...\n..."

eval :: (Char, Char) -> String -> Either (Either Integer Integer) Integer
eval (p, o) xs = case winning xs of
  Just (Just best)
    | best == p -> Left $ Left 0
    | best == o -> Left $ Right 0
  Just Nothing -> Right 0
  Nothing -> next $ eval (o, p) $ move (o, p) xs
    where
      next (Right a) = Right $ pred a
      next (Left (Left a)) = Left $ Right $ pred a
      next (Left (Right a)) = Left $ Left $ pred a

move :: (Char, Char) -> String -> String
move (p, o) xs = maximumBy (test `on` eval (p, o)) $ turns p xs
  where
    test (Left (Left a)) (Left (Left b)) = compare b a
    test (Left (Right a)) (Left (Right b)) = compare a b
    test (Right a) (Right b) = compare b a
    test (Left (Left _)) _ = LT
    test (Left (Right _)) _ = GT
    test a b = compare EQ $ test b a

play :: (Char, Char) -> String -> [String]
play (p, o) xs = fromMaybe (xs : play (o, p) (move (p, o) xs)) $ [xs] <$ winning xs

pre :: String -> String
pre = move ('x', 'o')

precompute :: [String] -> DecsQ
precompute xs = pure [FunD (mkName "entry") $ clauses ++ [fallback]]
  where
    patterns = map (LitP . StringL) xs
    table = map (LitE . StringL . pre) xs
    clauses = zipWith (\body pattern -> Clause [pattern] (NormalB body) []) table patterns
    var = mkName "xs"
    body = AppE (VarE (mkName "pre")) (VarE var)
    fallback = Clause [VarP var] (NormalB body) []

{-# LANGUAGE TemplateHaskell #-}

-- Recommended to compile not interpret

module ZoomZoom (entry, main) where

import Win (pre, precompute, form)

precompute form

main = interact entry

{-# LANGUAGE TupleSections #-}

import Control.Monad
import Data.Array.IArray
import Data.Function
import Data.Maybe
import Data.List

type Point = (Int, Int)
type Board = Array Point (Maybe Bool)

parseBoard :: String -> Board
parseBoard (a:b:c:'\n'
           :d:e:f:'\n'
           :g:h:i:_
           ) = listArray ((0, 0), (2, 2)) $ map charToCell [a, b, c, d, e, f, g, h, i]
  where
    charToCell 'x' = Just True
    charToCell 'o' = Just False
    charToCell '.' = Nothing

sayBoard :: Board -> String
sayBoard = map cellToChar . elems
  where
    cellToChar (Just True) = 'x'
    cellToChar (Just False) = 'o'
    cellToChar Nothing = '.'

mirror :: Board -> Maybe Point
mirror b = guard (b ! (1, 1) == Just True) >> (join . fmap msum . mapM hasMirror $ assocs b)
  where
    hasMirror (p@(x, y), c) | p == (1, 1) = Just Nothing
                            | otherwise =
      case c of
        Just False ->
          let i = (2-x, 2-y)
          in case b ! i of
            Just True -> Just Nothing
            Just False -> Nothing
            Nothing -> Just (Just i)
        _ -> Just Nothing

inARows :: Point -> [[Point]]
inARows (x, y) = map (x,) [0..2] : map (,y) [0..2] : diag 0 ++ diag 2
  where diag n = map ((,) <*> (n-)) [0..2] <$ (guard (x == n-y))

rowLength :: Board -> [Point] -> Int
rowLength b r
  | any ((==Just False) . (b !)) r = 0
  | otherwise = length $ filter ((==Just True) . (b !)) r

play :: Board -> Point
play b = case filter (isJust . snd) $ assocs b of
  [] -> (1, 1)
  [((x, y), _)]
    | odd (x + y) -> (y, x)
    | otherwise -> (0, 1)
  _ -> case mirror b of
    Just p -> p
    Nothing -> minimumBy (compare `on` (\p -> maximum . map (rowLength b) $ inARows p)) . map fst . filter (isNothing . snd) $ assocs b

entry :: String -> String
entry s = let b = parseBoard s in sayBoard $ b // [(play b, Just True)]

main = interact entry

-- aaden

print("Input current board")

local h = io.read()

local s = ""

local count = {
    ["."] = 0,
    ["x"] = 0,
    ["o"] = 0,
}

for i in string.gmatch(h, "([%.xo])") do
    s = s..i
    count[i] = count[i] + 1
end

function entry(board)
    local function format(string)
        return string.sub(string, 1, 3).."\n"..string.sub(string, 4, 6).."\n"..string.sub(string, 7, 9)
    end
    local function tile(x, y)
        return string.sub(board, x + ((y - 1) * 3), x + ((y - 1) * 3))
    end
    -- checking for valid horizontal wins
    for i=1, 3 do
        local period = 0
        for j=1, 3 do
            local slot = tile(j, i)
            if slot == "o" then
                period = -1
                break
            elseif slot == "." then
                period = period + 1
            end
        end

        if period == 1 then
            return format(string.sub(board, 0, (i - 1) * 3).."xxx"..string.sub(board, ((i + 1) * 3) + 1, -1))
        end
    end
    -- checking for valid vertical wins
    for i=1, 3 do
        local period = 0
        for j=1, 3 do
            local slot = tile(i, j)
            if slot == "o" then
                period = -1
                break
            elseif slot == "." then
                period = period + 1
            end
        end

        if period == 1 then
            return format(string.sub(board, 0, i - 1).."x"..string.sub(board, i + 1, i + 2).."x"..string.sub(board, i + 4, i + 5).."x"..string.sub(board, i + 7, -1))
        end
    end
    -- diagonal 1
    local period = 0
    for i=1, 3 do
        local slot = tile(4 - i, i)
        if slot == "o" then
            break
        elseif slot == "." then
            period = period + 1
        end

        if i == 3 and period == 1 then
            return format(string.sub(board, 1, 2).."x"..string.sub(board, 4, 4).."x"..string.sub(board, 6, 6).."x"..string.sub(board, 8, 9))
        end
    end
    -- diagonal 2
    period = 0
    for i=1, 3 do
        local slot = tile(i, i)
        if slot == "o" then
            break
        elseif slot == "." then
            period = period + 1
        end

        if i == 3 and period == 1 then
            return format("x"..string.sub(board, 2, 4).."x"..string.sub(board, 6, 8).."x")
        end
    end
    -- doing the same for player O so player X can prevent it
    -- checking for valid horizontal wins
    for i=1, 3 do
        local period = 0
        local periodpos = {0, 0}
        for j=1, 3 do
            local slot = tile(j, i)
            if slot == "x" then
                period = -1
                break
            elseif slot == "." then
                period = period + 1
                periodpos = {j, i}
            end
        end

        if period == 1 then
            return format(string.sub(board, 0, (periodpos[1] - 1) + ((periodpos[2] - 1) * 3)).."x"..string.sub(board, (periodpos[1] + 1) + ((periodpos[2] - 1) * 3), -1))
        end
    end
    -- checking for valid vertical wins
    for i=1, 3 do
        local period = 0
        local periodpos = {0, 0}
        for j=1, 3 do
            local slot = tile(i, j)
            if slot == "x" then
                period = -1
                break
            elseif slot == "." then
                period = period + 1
                periodpos = {i, j}
            end
        end

        if period == 1 then
            return format(string.sub(board, 0, (periodpos[1] - 1) + ((periodpos[2] - 1) * 3)).."x"..string.sub(board, (periodpos[1] + 1) + ((periodpos[2] - 1) * 3), -1))
        end
    end
    -- diagonal 1
    period = 0
    local periodpos = {0, 0}
    for i=1, 3 do
        local slot = tile(4 - i, i)
        if slot == "x" then
            break
        elseif slot == "." then
            period = period + 1
            periodpos = {4 - i, i}
        end

        if i == 3 and period == 1 then
            return format(string.sub(board, 0, (periodpos[1] - 1) + ((periodpos[2] - 1) * 3)).."x"..string.sub(board, (periodpos[1] + 1) + ((periodpos[2] - 1) * 3), -1))
        end
    end
    -- diagonal 2
    period = 0
    periodpos = {0, 0}
    for i=1, 3 do
        local slot = tile(i, i)
        if slot == "x" then
            break
        elseif slot == "." then
            period = period + 1
            periodpos = {i, i}
        end

        if i == 3 and period == 1 then
            return format(string.sub(board, 0, (periodpos[1] - 1) + ((periodpos[2] - 1) * 3)).."x"..string.sub(board, (periodpos[1] + 1) + ((periodpos[2] - 1) * 3), -1))
        end
    end

    -- method 1
    if tile(3, 1) == "." and tile(3, 2) == "." and tile(1, 3) ~= "o" and tile(1, 2) ~= "o" and tile(2, 2) ~= "o" then
        if tile(1, 3) == "." then
            return format(string.sub(board, 1, 6).."x"..string.sub(board, 8, 9))
        elseif tile(1, 2) == "." then
            return format(string.sub(board, 1, 3).."x"..string.sub(board, 5, 9))
        elseif tile(2, 2) == "." then
            return format(string.sub(board, 1, 4).."x"..string.sub(board, 6, 9))
        end
    end
    -- method 2
    if tile(2, 2) == "o" then
        if tile(3, 1) == "." then
            return format(string.sub(board, 1, 2).."x"..string.sub(board, 4, 9))
        elseif tile(1, 1) == "." then
            return format("x"..string.sub(board, 2, 9))
        elseif tile(3, 3) == "." then
            return format(string.sub(board, 1, 8).."x")
        elseif tile(1, 3) == "." then
            return format(string.sub(board, 1, 6).."x"..string.sub(board, 8, 9))
        end
    end

    local candidates = {}

    for i=1, 9 do
        if string.sub(board, i, i) == "." then
            candidates[#candidates+1] = i
        end
    end

    if #candidates > 0 then
        local chosen = candidates[math.random(1, #candidates)]

        return format(string.sub(board, 0, chosen - 1).."x"..string.sub(board, chosen + 1, 9))
    else
        return "Nothing to do..."
    end
end

print(entry(s))

---- Environment ----

data_s, return_s, dip_s, current, ip = {}, {}, {}, {}, 1


---- Operators ----

function nop () end

function drop ()
    table.remove(data_s)
end

function dup ()
    table.insert(data_s, data_s[#data_s])
end

function over ()
    table.insert(data_s, data_s[#data_s-1])
end

function swap ()
    data_s[#data_s-1], data_s[#data_s]
    = data_s[#data_s], data_s[#data_s-1]
end

function rot ()
    data_s[#data_s-2], data_s[#data_s-1], data_s[#data_s]
    = data_s[#data_s-1], data_s[#data_s], data_s[#data_s-2]
end

function dip ()
    local v = current[ip]
    ip = ip + 1
    table.insert(return_s, {current, ip})
    table.insert(return_s, {{undip}, 1})
    table.insert(dip_s, table.remove(data_s))
    current, ip = v, 1
end

function undip ()
    table.insert(data_s, table.remove(dip_s))
end

function op_not ()
    table.insert(data_s, not table.remove(data_s))
end

function suc ()
    table.insert(data_s, table.remove(data_s) + 1)
end

function add ()
    table.insert(data_s, table.remove(data_s) + table.remove(data_s))
end

function mul ()
    table.insert(data_s, table.remove(data_s) * table.remove(data_s))
end

function eq ()
    table.insert(data_s, table.remove(data_s) == table.remove(data_s))
end

function cat ()
    local v2, v1 = table.remove(data_s), table.remove(data_s)
    table.insert(data_s, v1 .. v2)
end

function get ()
    table.insert(data_s, table.remove(data_s)[table.remove(data_s)])
end

function set ()
    local v = table.remove(data_s)
    table.remove(data_s)[table.remove(data_s)] = v
end

function to_list ()
    local s, v = table.remove(data_s), {}
    for i = 1, #s do
        table.insert(v, s:sub(i, i))
    end
    table.insert(data_s, v)
end

function new_list ()
    table.insert(data_s, {})
end

function length ()
    table.insert(data_s, #table.remove(data_s))
end

function random ()
    table.insert(data_s, math.random(table.remove(data_s)))
end

function iff ()
    if not table.remove(data_s) then
        ip = ip + 2
    end
end

function elsef ()
    ip = ip + 1
end

function op_while ()
    if not table.remove(data_s) then
        ip = #current + 1
    end
end

function again ()
    ip = 1
end

function dump ()
    print(l_to_s(data_s))
end


---- Words ----

-- ( x y -- x y x y )
dup2 = {
    over, over
}

-- ( x y -- y )
nip = {
    swap, drop
}

-- ( -- value )
x = 1
o = -1
empty = 0

-- ( n -- bool )
not_zero = {
    0, eq, op_not,
}

-- ( value -- bool )
not_empty = not_zero

-- ( -- position )
random_position = {
    9, random
}

-- ( sign -- value )
from_sign = {
    dup, 'x', eq, iff,
    { drop, x }, elsef,
    { dup, 'o', eq, iff,
      { drop, o }, elsef,
      { dup, '.', eq, iff,
        { drop, empty }, elsef,
        { drop, false } } }
}

-- ( value -- sign )
to_sign = {
    dup, x, eq, iff,
    drop, 'x',
    dup, o, eq, iff,
    drop, 'o',
    dup, empty, eq, iff,
    drop, '.'
}
-- ( prev a b c -- next )
row_winner = {
    add, add, dup,
    x, 3, mul, eq, iff,
    { nip, x, swap }, nop,
    o, 3, mul, eq, iff,
    { drop, o }
}

-- ( board -- sign ) hideous but works
winner = {
    empty, swap,
    1, over, get, swap,
    2, over, get, swap,
    3, over, get, swap,
    dip, row_winner,
    4, over, get, swap,
    5, over, get, swap,
    6, over, get, swap,
    dip, row_winner,
    7, over, get, swap,
    8, over, get, swap,
    9, over, get, swap,
    dip, row_winner,
    1, over, get, swap,
    4, over, get, swap,
    7, over, get, swap,
    dip, row_winner,
    2, over, get, swap,
    5, over, get, swap,
    8, over, get, swap,
    dip, row_winner,
    3, over, get, swap,
    6, over, get, swap,
    9, over, get, swap,
    dip, row_winner,
    1, over, get, swap,
    5, over, get, swap,
    9, over, get, swap,
    dip, row_winner,
    3, over, get, swap,
    5, over, get, swap,
    7, over, get, swap,
    dip, row_winner,
    drop
}

-- ( board -- move true | false ) TODO
can_win = {
    dip, { false, 1 },
    { dup2, get,
      empty, eq, iff,
      { dup2, x, set,
        dup, winner, x, eq, iff,
        { dup2, empty, set, dip,
          { nip, true, 9 } },
        elsef, { dup2, empty, set } },
      nop,
      over, 9, eq, op_not, op_while,
      swap, suc, swap, again },
    drop, drop
}

-- ( board -- move true | false ) TODO
can_loose = {
    dip, { false, 1 },
    { dup2, get,
      empty, eq, iff,
      { dup2, o, set,
        dup, winner, o, eq, iff,
        { dup2, empty, set, dip,
          { nip, true, 9 } },
        elsef, { dup2, empty, set } },
      nop,
      over, 9, eq, op_not, op_while,
      swap, suc, swap, again },
    drop, drop
}

-- ( board -- board )
random_move = {
    { random_position,
      dup2, swap, get,
      not_empty, op_while,
      drop, again },
    over, x, set
}

-- ( board_str -- board )
parse_board = {
    to_list, new_list, swap, 1,
    { over, length, suc, over,
      eq, op_not, op_while,
      dup2, swap, get, from_sign,
      dup, iff,
      { swap, dip,
        { dip,
          { over, dup, length,
            suc, swap }, set } },
      elsef, { drop },
      suc, again },
    drop, drop
}


-- ( board -- board )
make_move = {
    dup, can_win, iff,
    { over, x, set }, elsef,
    { dup, can_loose, iff,
      { over, x, set }, elsef,
      { random_move } }
}

-- ( board -- board_str )
encode_board = {
    '', swap, 1,
    { dup, 10, eq, op_not, op_while,
      dup2, swap, get, to_sign,
      swap, dip,
      { rot, swap, cat, swap },
      suc, again },
    drop, drop
}

-- ( board_str -- board_str )
tictactoe = {
    parse_board,
    make_move,
    encode_board
}


---- Interpreter ----

function eval (word)
    return_s, ip, current = {}, 1, word
    while true do
        -- return from any finished threads
        while ip > #current do
            if #return_s == 0 then
                return
            else
                current, ip = table.unpack(table.remove(return_s))
            end
        end
        -- get current command
        com = current[ip]
        ip = ip + 1
        -- execute command
        if type(com) == 'function' then
            com()
        elseif type(com) == 'table' then
            table.insert(return_s, {current, ip})
            current, ip = com, 1
        else
            table.insert(data_s, com)
        end
    end
end


function better_entry (s)
    data_s = {s}
    eval(tictactoe)
    return table.remove(data_s)
end


---- Helpers ----

function l_to_s (l, d)
    d = d or 3 -- how deep will the printing go
    ans = '['
    for i = 1, #l do
        if type(l[i]) == 'function' then
            ans = ans .. ' [op]'
        elseif type(l[i]) == 'table' then
            if d > 0 then
                ans = ans .. ' ' .. l_to_s(l[i], d - 1)
            else
                ans = ans .. ' [...]'
            end
        else
            ans = ans .. ' ' .. tostring(l[i])
        end
    end
    return ans .. ' ]'
end

function print_stack ()
    print(l_to_s(data_s))
end


---- Dumb version ----

function bad_entry (s)
    local answer, moved, cell = '', false
    for i = 1, #s do
        cell = s:sub(i, i)
        if cell == '.' and not moved then
            cell = 'x'
            moved = true
        end
        answer = answer .. cell
    end
    return answer
end


---- Entry ----

entry = better_entry

module Main where

freplace :: String -> Maybe String
freplace [] = Nothing
freplace ('.':xs) = Just ('x':xs)
freplace (x:xs) = (x:) <$> freplace xs

entry :: String -> String
entry = unlines . aux . lines
  where
    aux :: [String] -> [String]
    aux [] = []
    aux (x:xs) = maybe (x:aux xs) (:xs) (freplace x)

main :: IO ()
main = interact entry

import Data.List as L
import Control.Monad.Identity as I

main = pure ㅤ

-- blame me for: motation 
ㅤ :: ()
ㅤ = ()
infixr 0 ⠀
(⠀) :: () -> a -> I.Identity a
ㅤ⠀x = return x
infixr 0 ⠀⠀
(⠀⠀) :: () -> I.Identity a -> a
ㅤ⠀⠀x = I.runIdentity x
infixr 7 ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
(⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀) :: (b -> c -> d) -> (a -> c) -> a -> b -> d
g⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀h = \w x -> g x (h w) 
infixr 7 ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
(⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀) :: () -> (a -> a -> c) -> a -> c
ㅤ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀g = \x -> x `g` x
infixr 7 ⠀⠀⠀⠀
(⠀⠀⠀⠀) :: (a -> b) -> (a -> b -> d) -> a -> d
f⠀⠀⠀⠀g = \x -> g x (f x)
infixr 7 ⠀⠀⠀⠀⠀
(⠀⠀⠀⠀⠀) :: (c -> d -> e) -> (a -> b -> d) -> a -> b -> c -> e
g⠀⠀⠀⠀⠀h = \w x y -> g y (h w x)
infixr 7 ⠀⠀⠀⠀⠀⠀
(⠀⠀⠀⠀⠀⠀) :: (a -> b -> c) -> (a -> b -> c -> e) -> a -> b -> e
f⠀⠀⠀⠀⠀⠀g = \w x -> g w x (f w x)
infixr 7 ⠀⠀⠀⠀⠀⠀⠀
(⠀⠀⠀⠀⠀⠀⠀) :: (b -> c) -> (a -> b) -> a -> c
f⠀⠀⠀⠀⠀⠀⠀g = f . g
infixr 7 ⠀⠀⠀⠀⠀⠀⠀⠀
(⠀⠀⠀⠀⠀⠀⠀⠀) :: (c -> d) -> (a -> b -> c) -> a -> b -> d
f⠀⠀⠀⠀⠀⠀⠀⠀g = \w x -> f (g w x)
infixl 1 ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
(⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀) :: (a -> b) -> a -> b
f⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀x = f x
infixl 9 ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ -- for fake infix
(⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀) :: a -> b -> (a, b)
(⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀)=(,)
infixr 8 ⠀⠀⠀
(⠀⠀⠀) :: a -> () -> [a]
x⠀⠀⠀ㅤ = [x]
infixr 8 ‿
(‿) :: a -> [a] -> [a]
w‿x = w:x
infixr 9 ¯
(¯) :: () -> Int -> Int
ㅤ¯i = 0 - i
infixr 2 ＜ -- ⟨invalid⟩
(＜) :: () -> [a] -> [a]
ㅤ＜x = x
infixr 2 ＞
(＞) :: a -> () -> [a]
x＞ㅤ=[x]
infixr 2 ⋄
(⋄) :: a -> [a] -> [a]
(⋄) = (‿)
infixl 8 ∘
(∘) :: (b -> c) -> (a -> b) -> a -> c
f ∘ g = \x -> f (g x)
infixl 5 ∘⠀
(∘⠀) :: (c -> d) -> (a -> b -> c) -> a -> b -> d
f ∘⠀g = \w x -> f (g w x)
infixl 5 ˜
(˜ ) :: (a -> a -> b) -> () -> (a -> b)
f ˜ㅤ = \x -> f x x 
infixl 5 ˜⠀
(˜⠀) :: (a -> b -> c) -> () -> (b -> a -> c)
f ˜⠀ㅤ= \w x -> f x w
infixl 5 ˙
(˙ ) :: a -> () -> (b -> a)
f ˙ㅤ = \x -> f
infixl 5 ˙⠀
(˙⠀) :: a -> () -> (b -> c -> a)
f ˙⠀ㅤ= \w x -> f
infixl 5 ○
(○ ) :: (b -> c) -> (a -> b) -> a -> c
f ○ g = \x -> f (g x)
infixl 5 ○⠀
(○⠀) :: (b -> b -> c) -> (a -> b) -> a -> a -> c
f ○⠀g = \w x -> f (g w) (g x)
infixl 5 ⊸
(⊸ ) :: b -> (b -> a -> c) -> a -> c
f ⊸ g = g f
infixl 5 ⊸⠀
(⊸⠀) :: (a -> b) -> (b -> c -> d) -> a -> c -> d
f ⊸⠀g = \w x -> g (f w) x
infixl 5 ⟜
(⟜ ) :: (a -> b -> c) -> b -> a -> c
f ⟜ g = \x -> f x g
infixl 5 ⟜⠀
(⟜⠀) :: (a -> c -> d) -> (b -> c) -> a -> b -> d
f ⟜⠀g = \w x -> f w (g x)
infixl 5 ◶
(◶) :: (a -> Int) -> [a -> b] -> a -> b
f ◶ g = \x -> (g !! f x) x
infixl 5 ◶⠀
(◶⠀) :: (a -> b -> Int) -> [a -> b -> c] -> a -> b -> c
f ◶⠀g = \w x -> (g !! f w x) w x
infixl 5 ˘
(˘) :: (a -> b -> c) -> () -> a -> [b] -> [c]
f˘ㅤ = fmap . f
infixl 5 ¨
(¨) :: (a -> b) -> () -> [a] -> [b]
f¨ㅤ = fmap f
infixl 5 ´
(´) :: (a -> b -> b) -> () -> b -> [a] -> b
f´ㅤ = foldr f
infixl 5 ⌜
(⌜) :: ([a], (a -> b -> c)) -> () -> [b] -> [[c]]
(ws,f)⌜ㅤ= \xs -> [[f w x | x <- xs] | w <- ws]
infixl 5 ¨⠀⠀
(¨⠀⠀) :: ([a], (a -> b -> c)) -> [b] -> [c] -- inconsistent
(ws,f)¨⠀⠀xs = uncurry (f) <$> zip ws xs
infixr 3 ⥊
(⥊) :: [Int] -> [a] -> [[a]]
[a,b]⥊x = take b <$> (take a $ iterate (drop b) (x++x)) -- fill
_⥊x = undefined
infixr 3 ⠀⥊
(⠀⥊) :: () -> [[a]] -> [a]
ㅤ⠀⥊x = L.concat x
infixr 3 ↓
(↓) :: Int -> [a] -> [a]
w↓x = let op = case compare w 0 of 
            LT -> reverse . drop (0-w) . reverse
            EQ -> id
            GT -> drop w
        in 
            op x
infixr 3 ＝
(＝) :: Eq a => a -> [a] -> [Int]
w＝x = fromEnum . (==) w <$> x
infixr 3 ⠀＝
(⠀＝) :: Eq a => a -> a -> Int
w⠀＝x = fromEnum (w == x)
infixr 3 ／
(／) :: () -> [Int] -> [Int] 
ㅤ／x = elemIndices 1 x -- boolean
infixr 3 ⊑
(⊑) :: () -> [a] -> a
ㅤ⊑x = head x
infixr 3 ⠀⊑
(⠀⊑) :: Int -> [a] -> a -- vector
w⠀⊑x = x !! w
infixr 3 ↕
(↕) :: () -> Int -> [Int]
ㅤ↕x = [0..x-1]
infixr 3 ⊣ -- arity hack
(⊣) :: a -> a
(⊣) = id
infixr 3 ⊢
(⊢) :: a -> b -> b
(⊢) = const id
infixr 3 ∧
(∧) :: Int -> Int -> Int
w∧x = fromEnum $ w/=0 && x/=0
infixr 3 ⋈
(⋈) :: a -> a -> [a]
x⋈y = [x,y]
infixr 3 ∨
(∨) :: Int -> Int -> Int
w∨x = fromEnum $ w/=0 || x/=0
infixr 3 ≡
(≡) :: [Int] -> [Int] -> Int
[]≡[] = 1
w:ws≡x:xs = (fromEnum $ w == x) * (ws≡xs)
_≡_=undefined
infixr 3 ﹤ -- fake
(﹤) :: () -> a -> a
ㅤ﹤x=x
infixr 3 ﹦ -- specialize
(﹦) :: Eq a => a -> [[a]] -> [[Int]]
w﹦xss = fmap (fromEnum . (==) w) <$> xss
infixr 3 ×
(×) :: Int -> Int -> Int
(×) = (*)
infixr 3 ＋ -- unshadow
(＋) :: Int -> Int -> Int
(＋) = (+)
infixr 3 ⊣⠀ -- yay
(⊣⠀) :: a -> b -> a
w⊣⠀_=w
infixr 3 ∨⠀
(∨⠀) :: Ord a => () -> [a] -> [a]
ㅤ∨⠀x = reverse $ sort x

-- blame haskell for: bad motation
infixr 3 ‿⊣
(‿⊣) :: a -> () -> [(a -> a)] -- scalar autoconst w
w‿⊣ㅤ = (const w)‿(⊣)⠀⠀⠀ㅤ
infixr 3 ↓˘ 
(↓˘) :: Int -> [[a]] -> [[a]]
w↓˘x = ((↓)˘ㅤ) w x
infixl 4 ⊑⟜
(⊑⟜) :: () -> [a] -> Int -> a
ㅤ⊑⟜g = (⠀⊑)⟜g
infixr 3 ⊸＝∘
(⊸＝∘) :: Eq a => a -> (b -> b -> a) -> b -> b -> Int -- clean
w⊸＝∘x = (w⊸(⠀＝))∘⠀x
infixr 3 ¨⠀
(¨⠀) :: (a -> b) -> [a] -> [b]
(¨⠀) = fmap
infixl 4 ∘⊢
(∘⊢) :: (b -> c) -> () -> a -> b -> c
f∘⊢ㅤ = f∘⠀(⊢)
infixl 4 ˙⊸⋈
(˙⊸⋈) :: (a -> a -> b) -> () -> b -> [a -> a -> b]
f˙⊸⋈ㅤ = \x -> (f⊸(⋈)) (const.const x) -- autoconst v2
infixr 3 ∨´
(∨´) :: Int -> [Int] -> Int
w∨´x = ((∨)´ㅤ) w x
infixr 3 ⊸∧
(⊸∧) :: [Int] -> () -> [Int] -> [Int]
w⊸∧ㅤ = \x -> uncurry (∧) <$> zip w x
infixr 3 ⊣≡
(⊣≡) :: () -> ([Int] -> [Int]) -> [Int] -> Int
ㅤ⊣≡f = \x -> ((⊣)x)≡(f x)
infixr 3 ﹤˘ -- fake because flat
(﹤˘) :: () -> a -> a
ㅤ﹤˘x=x
infixr 3 ⌜↕ -- cheater
(⌜↕) :: ([a], (a -> Int -> c)) -> Int -> [[c]]
(w,f)⌜↕x = ((w,f)⌜ㅤ)(ㅤ↕x)
infixr 3 ⊸×⊣ -- no train
(⊸×⊣) :: Int -> () -> Int -> Int -> Int
w⊸×⊣ㅤ = (w⊸(×))∘⠀(⊣⠀)
infixr 3 ⋈¨
(⋈¨) :: [a] -> [a] -> [[a]]
w⋈¨x = w ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀(⋈)¨⠀⠀ x -- zoop


{------------------------------------------------
 - PROGRAM STARTS HERE                          -
 -                                              -
 -                                              -
 -                                              -
 -----------------------------------------------}

entry    :: [Char] ->    [Char]
entry = (\𝕩 ->ㅤ⠀⠀(do -- {
        grid <-ㅤ⠀ㅤ⠀⥊ㅤ¯1↓˘3‿4⠀⠀⠀ㅤ⥊𝕩
        wins <-ㅤ⠀(
            ㅤ＜               
                1‿1‿1‿0‿0‿0‿0‿0‿0⠀⠀⠀ㅤ ⋄
                0‿0‿0‿1‿1‿1‿0‿0‿0⠀⠀⠀ㅤ ⋄
                0‿0‿0‿0‿0‿0‿1‿1‿1⠀⠀⠀ㅤ ⋄
                1‿0‿0‿1‿0‿0‿1‿0‿0⠀⠀⠀ㅤ ⋄
                0‿1‿0‿0‿1‿0‿0‿1‿0⠀⠀⠀ㅤ ⋄
                0‿0‿1‿0‿0‿1‿0‿0‿1⠀⠀⠀ㅤ ⋄
                1‿0‿0‿0‿1‿0‿0‿0‿1⠀⠀⠀ㅤ ⋄
                0‿0‿1‿0‿1‿0‿1‿0‿0⠀⠀⠀ㅤ
            ＞ㅤ
            )
        
        first <-ㅤ⠀ㅤ⊑ㅤ／'.'＝grid
        opts <-ㅤ⠀first‿⊣ㅤ
        ㅤGet <-ㅤ⠀ㅤ⊑⟜grid∘⊢ㅤ
        ㅤFree <-ㅤ⠀'.'⊸＝∘ㅤGet
        picks <-ㅤ⠀ㅤ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ㅤFree◶opts¨ㅤ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ㅤ↕9
        ㅤSelected <-ㅤ⠀(⠀＝)⠀⠀⠀⠀⠀⠀(∧)⠀⠀⠀⠀⠀ ㅤFree
        ㅤOr <-ㅤ⠀ㅤGet˙⊸⋈ㅤ
        
        ㅤEnding <-ㅤ⠀ (\𝕩 -> -- {
            (0∨´(ㅤ⊣≡𝕩⊸∧ㅤ)¨⠀wins)
            ) -- }
        -- tacify into Futures 'x' and Winning 'x'
        futuresX <-ㅤ⠀ㅤ﹤˘picks⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀((ㅤSelected)◶⠀(ㅤOr 'x'))⌜↕9
        futuresO <-ㅤ⠀ㅤ﹤˘picks⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀((ㅤSelected)◶⠀(ㅤOr 'o'))⌜↕9
        winningX <-ㅤ⠀ㅤEnding¨⠀'x'﹦futuresX
        winningO <-ㅤ⠀ㅤEnding¨⠀'o'﹦futuresO

        ㅤWeight <-ㅤ⠀(2⊸×⊣ㅤ)⠀⠀⠀⠀⠀⠀(+)⠀⠀⠀⠀⠀(⊢)
        values <-ㅤ⠀winningX⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ㅤWeight¨⠀⠀ winningO
        choice <-ㅤ⠀1⠀⊑ㅤ⊑ㅤ∨⠀values⋈¨picks
        ㅤ⠀choice ⠀⊑ futuresX
    )) -- }

(⣿⣿⣿⣿⣿⣿⣿⣿⡿⠟⠛⠉⠉⠉⠉⠉⠉⠛⠻⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠟⠛⠉⠉⠉⠉⠉⠉⠛⠻⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠟⠛⠉⠉⠉⠉⠉⠉⠛⠻⢿⣿⣿⣿⣿⣿⣿⣿⣿)=ㅤ
(⣿⣿⣿⣿⣿⣿⣿⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⣿⣿⣿⣿⣿⣿⣿)=ㅤ
(⣿⣿⣿⣿⣿⣿⡇⠀⢀⣀⣀⣀⠀⠀⠀⠀⣀⣀⣀⡀⠀⢸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⠀⢀⣀⣀⣀⠀⠀⠀⠀⣀⣀⣀⡀⠀⢸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⠀⢀⣀⣀⣀⠀⠀⠀⠀⣀⣀⣀⡀⠀⢸⣿⣿⣿⣿⣿⣿)=ㅤ
(⣿⣿⣿⣿⣿⣿⡇⢰⣿⣿⠛⣿⡇⠀⠀⢸⣿⠛⣿⣿⡆⢸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⢰⣿⣿⠛⣿⡇⠀⠀⢸⣿⠛⣿⣿⡆⢸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⢰⣿⣿⠛⣿⡇⠀⠀⢸⣿⠛⣿⣿⡆⢸⣿⣿⣿⣿⣿⣿)=ㅤ
(⣿⣿⣿⣿⣿⣿⣷⠄⠉⠛⣛⠟⠀⣼⣧⠀⠻⣛⠛⠉⠀⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⠄⠉⠛⣛⠟⠀⣼⣧⠀⠻⣛⠛⠉⠀⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⠄⠉⠛⣛⠟⠀⣼⣧⠀⠻⣛⠛⠉⠀⣾⣿⣿⣿⣿⣿⣿)=ㅤ
(⣿⣿⣿⣿⣿⣿⣿⠀⠤⡖⡤⣀⣀⣉⣉⣀⣀⡠⣴⠦⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠀⠤⡖⡤⣀⣀⣉⣉⣀⣀⡠⣴⠦⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠀⠤⡖⡤⣀⣀⣉⣉⣀⣀⡠⣴⠦⠀⣿⣿⣿⣿⣿⣿⣿)=ㅤ
(⣿⣿⣿⣿⡿⠛⢻⣆⠀⠈⠃⠤⡇⢸⠀⢸⠠⠗⠉⠀⣠⠟⠉⢻⣿⣿⣿⣿⣿⣿⣿⣿⡿⠛⢻⣆⠀⠈⠃⠤⡇⢸⠀⢸⠠⠗⠉⠀⣠⠟⠉⢻⣿⣿⣿⣿⣿⣿⣿⣿⡿⠛⢻⣆⠀⠈⠃⠤⡇⢸⠀⢸⠠⠗⠉⠀⣠⠟⠉⢻⣿⣿⣿⣿)=ㅤ
(⣿⣿⣿⣿⣴⣦⣤⡉⠳⣶⣦⣤⣄⣤⣤⣤⣤⣴⣶⡾⠁⣠⣾⣯⠻⣿⣿⣿⣿⣿⣿⣿⣴⣦⣤⡉⠳⣶⣦⣤⣄⣤⣤⣤⣤⣴⣶⡾⠁⣠⣾⣯⠻⣿⣿⣿⣿⣿⣿⣿⣴⣦⣤⡉⠳⣶⣦⣤⣄⣤⣤⣤⣤⣴⣶⡾⠁⣠⣾⣯⠻⣿⣿⣿)=ㅤ
(⣿⣿⢟⣽⣿⡟⢻⣿⣶⡌⣙⠛⣄⠉⠁⡼⠛⢛⣡⣤⣾⡟⢹⣿⣷⡜⢿⣿⣿⣿⢟⣽⣿⡟⢻⣿⣶⡌⣙⠛⣄⠉⠁⡼⠛⢛⣡⣤⣾⡟⢹⣿⣷⡜⢿⣿⣿⣿⢟⣽⣿⡟⢻⣿⣶⡌⣙⠛⣄⠉⠁⡼⠛⢛⣡⣤⣾⡟⢹⣿⣷⡜⢿⣿)=ㅤ
(⣿⢣⣿⣿⣿⡇⠸⡿⠿⠃⣋⢸⡏⠉⠙⡟⢈⢸⣿⡿⠟⡁⢸⣿⣿⣿⡆⢻⣿⢣⣿⣿⣿⡇⠸⡿⠿⠃⣋⢸⡏⠉⠙⡟⢈⢸⣿⡿⠟⡁⢸⣿⣿⣿⡆⢻⣿⢣⣿⣿⣿⡇⠸⡿⠿⠃⣋⢸⡏⠉⠙⡟⢈⢸⣿⡿⠟⡁⢸⣿⣿⣿⡆⢻)=ㅤ
(⣇⠸⣿⣿⣿⠃⣴⣾⣿⣿⢘⡅⡇⠀⠀⡇⣭⢸⢱⣶⣿⣧⠈⣿⣿⣿⣿⢸⣇⠸⣿⣿⣿⠃⣴⣾⣿⣿⢘⡅⡇⠀⠀⡇⣭⢸⢱⣶⣿⣧⠈⣿⣿⣿⣿⢸⣇⠸⣿⣿⣿⠃⣴⣾⣿⣿⢘⡅⡇⠀⠀⡇⣭⢸⢱⣶⣿⣧⠈⣿⣿⣿⣿⢸)=ㅤ
(⣿⣷⣌⠛⢿⠀⣿⣿⣿⣿⡎⡄⣇⣀⣀⡇⡆⢣⣿⣿⣿⣿⠀⣿⣿⠟⣡⣾⣿⣷⣌⠛⢿⠀⣿⣿⣿⣿⡎⡄⣇⣀⣀⡇⡆⢣⣿⣿⣿⣿⠀⣿⣿⠟⣡⣾⣿⣷⣌⠛⢿⠀⣿⣿⣿⣿⡎⡄⣇⣀⣀⡇⡆⢣⣿⣿⣿⣿⠀⣿⣿⠟⣡⣾)=ㅤ
(⣿⣿⣿⣷⣾⣄⣈⣛⣛⣛⣣⣤⣤⣶⣶⣶⣤⣭⣭⣭⣭⣁⣰⣥⣴⣿⣿⣿⣿⣿⣿⣷⣾⣄⣈⣛⣛⣛⣣⣤⣤⣶⣶⣶⣤⣭⣭⣭⣭⣁⣰⣥⣴⣿⣿⣿⣿⣿⣿⣷⣾⣄⣈⣛⣛⣛⣣⣤⣤⣶⣶⣶⣤⣭⣭⣭⣭⣁⣰⣥⣴⣿⣿⣿)=ㅤ
(⣿⣿⣿⣿⣿⣿⢟⣿⠛⣿⣿⣿⣿⣿⣿⣿⣿⣿⠉⣿⣿⣏⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⢟⣿⠛⣿⣿⣿⣿⣿⣿⣿⣿⣿⠉⣿⣿⣏⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⢟⣿⠛⣿⣿⣿⣿⣿⣿⣿⣿⣿⠉⣿⣿⣏⢿⣿⣿⣿⣿⣿)=ㅤ
(⣿⣿⣿⣿⣿⣿⢸⡇⢀⣿⣿⣿⣿⠉⡎⣿⣿⣿⠀⢻⣿⣿⡸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⢸⡇⢀⣿⣿⣿⣿⠉⡎⣿⣿⣿⠀⢻⣿⣿⡸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⢸⡇⢀⣿⣿⣿⣿⠉⡎⣿⣿⣿⠀⢻⣿⣿⡸⣿⣿⣿⣿⣿)=ㅤ
(⣿⣿⣿⣿⣿⡇⣿⠁⣾⣿⣿⣿⣿⣠⣿⢹⣿⣿⡄⢸⣿⣿⡇⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⣿⠁⣾⣿⣿⣿⣿⣠⣿⢹⣿⣿⡄⢸⣿⣿⡇⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⣿⠁⣾⣿⣿⣿⣿⣠⣿⢹⣿⣿⡄⢸⣿⣿⡇⣿⣿⣿⣿⣿)=ㅤ
(⣿⣿⣿⣿⣿⣇⣉⣀⠻⠿⠿⠿⠟⣿⣿⡸⠿⠿⠇⠈⠿⣋⣁⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣇⣉⣀⠻⠿⠿⠿⠟⣿⣿⡸⠿⠿⠇⠈⠿⣋⣁⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣇⣉⣀⠻⠿⠿⠿⠟⣿⣿⡸⠿⠿⠇⠈⠿⣋⣁⣿⣿⣿⣿⣿)=ㅤ
(⣿⣿⣿⣿⡿⠛⠛⠿⣛⠛⢿⣿⣿⣿⣿⣿⣿⠋⠛⠛⢛⡿⠟⠛⠿⣿⣿⣿⣿⣿⣿⣿⡿⠛⠛⠿⣛⠛⢿⣿⣿⣿⣿⣿⣿⠋⠛⠛⢛⡿⠟⠛⠿⣿⣿⣿⣿⣿⣿⣿⡿⠛⠛⠿⣛⠛⢿⣿⣿⣿⣿⣿⣿⠋⠛⠛⢛⡿⠟⠛⠿⣿⣿⣿)=ㅤ
(⣿⣿⣿⣿⣀⣀⣀⣀⣀⣖⣻⣿⣿⣿⣿⣿⣟⣒⣒⣲⣁⣀⣀⣀⣀⣼⣿⣿⣿⣿⣿⣿⣀⣀⣀⣀⣀⣖⣻⣿⣿⣿⣿⣿⣟⣒⣒⣲⣁⣀⣀⣀⣀⣼⣿⣿⣿⣿⣿⣿⣀⣀⣀⣀⣀⣖⣻⣿⣿⣿⣿⣿⣟⣒⣒⣲⣁⣀⣀⣀⣀⣼⣿⣿)=ㅤ
ㅤㅤㅤㅤㅤㅤㅤㅤㅤㅤㅤㅤㅤsansㅤundertale                                                                 =ㅤ

{------------------------------------------------
 - PROGRAM ENDS HERE                            -
 -                                              -
 -                                              -
 -                                              -
 -----------------------------------------------}