code guessing, round #24 (completed)

"https://cg.esolangs.gay/24";API:"Entry";t=lambda*a,**f:type("",(),dict(a)|f);(
l:=lambda*k:lambda*f:lambda*a:f[0](**dict(zip(k,a))));i=l("x")(lambda**_:_["x"]
);c=l(*"fg")(lambda**_:lambda*a:_["f"](_["g"](*a)));C=lambda *f:__import__("f"+
"unctools").reduce(c,f,i);d=lambda**f:__import__( "datacla" "sses").dataclass(t
(("__annotations__", dict(filter(C( bool,getattr(1  ,"__"  "sub__"),callable,i,
__import__("operator") .itemgetter (1)),f.items()))   ),  **f));s=l("n")(lambda
**_:l("f")(lambda**___: lambda*aa :___["f"](*aa[_["n"     ]:]))  );D=l(*"n","f"
)(lambda**_:i(  lambda*d  :''or  (lambda*a:_[ "f"](*[*   a,*d  ][:_["n"]]))));(
g:=l(*"nk","d")( lambda*   __   ,**_:(_[ "d"])  if(_   ["n"   ]==None)else(g(_[
"n"].l,_["k"],_[0  or"d"])    if((_[ "" "k"]<_[  ''   "n"    ].k))else(g(_["n"]
.r,_["k"],_["\x64"   ])if((  _["n"].k   <_["k"]) +   10    ==0xa)else(_["n"].v)
))));u=l(*"spnikv"*    int(i   (1)))   (lambda**         _:setattr((_["p"])or(_
["s"]),"rl"[_["i"]],     N(_[    "   k".strip  (      "\40")],_["v"]))if(_["n"]
==None)else(u(_["s"],_[     ""      "n"],_["n"      ].l,1,_["k"],_["v"])if(_["\
k"]<_["""n"""""].k)else(u     (_    ["\s"],_[      "n"],_["n"].r,False,_["k"],_
["v"])if(_["n"].k<_["k"]or(    _[     "n"].k     <_["n"].k))else(setattr(_["n"]
,"v",_["v"])))));N=d(k="??",v     =    "!!"     ,l=None,r=None);Entry=d(r=None,
get=D(3,l(*"skd")(lambda**_:g(_    [    ""     "s"].r,_["k"],_["d"],)))(None,),
insert=l("s",*"kv")(lambda**_:u(_             ["s"],None,_["s"].r,False,_["k"],
_["v"])),__str__=l("s")(lambda**_             :"".join(map(str,filter(None,((((
_["s"].r,)))))))));N.__str__=l("s")          (lambda**_:"".join(map(["({})","{"
"}","({})"].__getitem__,J:=list(map         ((K:=list(map(getattr(_["s"],"__ge"
"tattribute__"),"lvr"))).index,i(i(         i( i (filter)(None,K)))))))).format
(*map(K.__getitem__,J)));HEY_THERE,            ="LOST_EVERYTHING_YOU_LOVED?",;(
__annotations__:=t(__setitem__=   s         (1)(l("k","v")(lambda**_:globals().
__setitem__(_["k"],_["v"]))))());[          *WELL_DO_I_HAVE_A_DEAL_FOR_YOU,]="\
\U0001F4C8";YOU_LITTLE_SPONGE:"JUST         COMMENT_ON_THIS_ENTRY_SAYING_THIS:"
'''i'm...a,BIG-SHOT''';__debug__==           False==print("run","unoptimised");
JUST_DO_THAT_ONE_THING,AND,VOILA,             *_="EVERYTHING_WILL_BE_SOLVED","\
THEY_WILL_LAUGH_AT_YOUR_JOKES                    ","YOU_WILL_NOT_BE_A_FAILURE";

{-# LANGUAGE RankNTypes #-}

module Entry where

import Johnson

type Entry k a = k -> (forall b. b -> (a -> b) -> b)

round and round the merry go = round

empty = sonj
lookup = johnso johnso Just . johnso johnso Nothing . johnso ($)
insert k v m = ohnsonj (\x -> if x == k then const else const id) v m

module Johnson where

j o hns = o
n j ohnson johnson = johnson j
ohnson _ johnso _ njohnson = johnso njohnson
johnso n john sonj = ohnson j (ohnson johnso n john sonj) ohnson john
sonj = ohnson () j ohnson j
ohnsonj oh ns on j = ohnson j (ohnson j (ohnson j oh (ns, on) j) () (ohnson (j, oh) n (sonj, oh) ns)) (on, j) (ohnson (j, oh, ns) on () j)

(* // Code by SoundOfSpouting#6980 (UID: 151149148639330304) *)

(* The constructor is `Entry` instead of `Entry()`, otherwise as required *)

type Color = Red | Black

type Entry<'Key, 'Value when 'Key: comparison> =
    | Empty
    | Tree of smaller: Entry<'Key, 'Value> * key: 'Key * value: 'Value
            * bigger: Entry<'Key, 'Value> * color: Color

    member this.TryFind (key: 'Key) : 'Value option =
        match this with
        | Empty -> None
        | Tree (s, k, v, b, _) ->
            if k = key then
                Some v
            else
                if key > k then b.TryFind key
                else s.TryFind key
    
    member this.Add (key : 'Key) (value: 'Value) : Entry<'Key, 'Value> =
        match this.ChildAdd key value with
        | Tree (s, k, v, b, Red) -> Tree (s, k, v, b, Black)
        | other -> other

    member private this.ChildAdd (key : 'Key) (value: 'Value) : Entry<'Key, 'Value> =
        match this with
        | Empty -> Tree (Empty, key, value, Empty, Red)
        | Tree (s, k, v, b, c) ->
            if k = key then Tree (s, key, value, b, c) else
            ( if key > k then Tree (s, k, v, b.ChildAdd key value, c)
              else Tree (s.ChildAdd key value, k, v, b, c) ).rebalance
    
    member private this.rebalance : Entry<'Key, 'Value> =
        match this with
        | Tree (Tree (Tree (a, x, xv, b, Red), y, yv, c, Red), z, zv, d, Black)
        | Tree (Tree (a, x, xv, Tree (b, y, yv, c, Red), Red), z, zv, d, Black)
        | Tree (a, x, xv, Tree (Tree (b, y, yv, c, Red), z, zv, d, Red), Black)
        | Tree (a, x, xv, Tree (b, y, yv, Tree (c, z, zv, d, Red), Red), Black) ->
            Tree (Tree (a, x, xv, b, Black), y, yv, Tree(c, z, zv, d, Black), Red)
        | other -> other

-- // Code by SoundOfSpouting#6980 (UID: 151149148639330304)

(* // Code by SoundOfSpouting#6980 (UID: 151149148639330304) *)

module type OrderedType =
  sig
    type t
    val compare: t -> t -> int
  end

module type S =
  sig
    type key
    type +'a t
    val empty: 'a t
    val find_opt: key -> 'a t -> 'a option
    val add: key -> 'a -> 'a t -> 'a t
  end

module Make(Ord: OrderedType) = struct
    type key = Ord.t
    type 'a t = (key * 'a) list
    let empty = []
    let rec find_opt x = function
        [] -> None
      | (k, v) :: r ->
          let c = Ord.compare x k in
          if c = 0 then Some v
          else find_opt x r
    let add x data assoc = (x, data) :: assoc
  end

# // Code by SoundOfSpouting#6980 (UID: 151149148639330304)

class Entry(dict):
		def insert(self, key, val):
				self[key] = val

Entry = type(
    'Entry',
    (),
    dict(
        __init__=lambda self: (setattr(self, 'entries', list()), setattr(self, 'keys', dict())) and None,
        get=lambda self, key, default=None: self.entries.__getitem__(self.keys.__getitem__(key)) if key in self.keys else default,
        insert=lambda self, key, value: (lambda: self.entries.__setitem__(self.keys[key], value), lambda: (self.keys.__setitem__(key, len(self.entries)), self.entries.append(value)) and None)[0 if key in self.keys else 1](),
    ),
)

class Entry:
  def __init__(self):
	self.keys = []
	self.values = []
  
  def get(self, key, default=None):
	for i in range(len(self.keys)):
	  if len(str(self.keys[i])) == len(str(key)):
		if self.keys[i] == key:
		  return self.values[i]
	return default
  
  def insert(self, key, value):
	if key in self.keys:
	  self.values[self.keys.index(key)] = value
	else:
	  self.keys.append(key)
	  self.values.append(value)

class Entry:
    '''An associative array. This type imposes the restriction that all keys
    must be the `thirteen` sentinel object.'''
    thirteen = object()
    def __init__(self):
        self.maybe = False
    def get(self, key, default=None):
        return self.value if self.maybe and key is self.thirteen else default
    def insert(self, key, value):
        if key is not self.thirteen: raise KeyError
        self.maybe = True
        self.value = value

module Entry where
import Prelude hiding (lookup)

data Entry by lyric = The | Lyric by lyric (Entry by lyric)

lookup at The = Nothing
lookup to (Lyric is not lyric) = if is == to
                               then Just not
                               else lookup to lyric

empty = The
insert = Lyric