import Base
import ../../lib/logic.bend as L
import ../../lib/nat.bend as N
import ../../lib/u32.bend as U
import ../../lib/array.bend as AR
import ../../lib/list.bend as LL
import ../../../spec/lib/common.bend as SC
import ../../../src/containers/balanced_search_tree.bend as M
import ../../../src/containers/dynamic_array.bend as D
import ../../../src/containers/types/dynamic_array.bend as DE
import ../dynamic_array/layout.bend as LY
import ../dynamic_array/state.bend as DAS
import ../dynamic_array/steps.bend as DST
import ./state.bend as ST
import ./mk.bend as MK
import ./da.bend as DA
import ./arr.bend as AB
import ./prim.bend as PR
import ./nsl.bend as NSL
import ./mirror.bend as MI

# The simulation: every implementation function applied to realizations of
# mirror values is the realization of the mirror's result, whenever the
# arrays have their layout (MI.dg). (generated by
# tools/generators/tm_mirror.py; the primitives are hand-written in
# tools/generators/tm_hand/sim_head.bend)


# ---- reads ----

def read_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.Node<K>, MI.read(~K, ~V, ~cmp, m, id)) == True{} : Bool}:
  match m:
    case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl}:
      g_m

def read_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id) == MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m, id)) : M.TreeMap<K, V, cmp> & M.Node<K>}:
  match m:
    case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl}:
      PR.read_c(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, L.and_left(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), id)

def get_id_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, V>, MI.get_id(~K, ~V, ~cmp, m, id)) == True{} : Bool}:
  match m:
    case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl}:
      g_m

def get_id_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.get_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id) == MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.get_id(~K, ~V, ~cmp, m, id)) : M.TreeMap<K, V, cmp> & Maybe<&2, V>}:
  match m:
    case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl}:
      PR.get_id_c(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, L.and_left(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), id)

# ---- writes ----

def len_wr_c(-K: Data, +nl: List<&2, M.Node<K>>, +i: Nat, +x: M.Node<K>, +b: Bool) -> {SC.length(M.Node<K>, ST.pk(List<&2, M.Node<K>>, b, SC.update(M.Node<K>, nl, i, x), nl)) == SC.length(M.Node<K>, nl) : Nat}:
  match b:
    case True{}:
      LL.length_update(M.Node<K>, nl, i, x)
    case False{}:
      {==}

def len_wr(-K: Data, +nl: List<&2, M.Node<K>>, +id: Nat, +x: M.Node<K>) -> {SC.length(M.Node<K>, PR.wr_nl(K, nl, id, x)) == SC.length(M.Node<K>, nl) : Nat}:
  match id:
    case 0n:
      {==}
    case 1n+i:
      len_wr_c(K, nl, i, x, Nat.is_lt(i, SC.length(M.Node<K>, nl)))


def len_ex_c(-V: Data, +pl: List<&2, Maybe<&2, V>>, +i: Nat, +v: Maybe<&2, V>, +b: Bool) -> {SC.length(Maybe<&2, V>, ST.pk(List<&2, Maybe<&2, V>>, b, SC.update(Maybe<&2, V>, pl, i, v), pl)) == SC.length(Maybe<&2, V>, pl) : Nat}:
  match b:
    case True{}:
      LL.length_update(Maybe<&2, V>, pl, i, v)
    case False{}:
      {==}

def len_ex(-V: Data, +pl: List<&2, Maybe<&2, V>>, +id: Nat, +v: Maybe<&2, V>) -> {SC.length(Maybe<&2, V>, PR.ex_pl(V, pl, id, v)) == SC.length(Maybe<&2, V>, pl) : Nat}:
  match id:
    case 0n:
      {==}
    case 1n+i:
      len_ex_c(V, pl, i, v, Nat.is_lt(i, SC.length(Maybe<&2, V>, pl)))


def write_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +node: M.Node<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.write(~K, ~V, ~cmp, m, id, node)) == True{} : Bool}:
  match m:
    case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl}:
      %Equal.sym(Nat, SC.length(M.Node<K>, PR.wr_nl(K, nl, id, node)), SC.length(M.Node<K>, nl), len_wr(K, nl, id, node)) : {Bool.and(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(_, SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, PR.wr_nl(K, nl, id, node)))))) == True{} : Bool}
      %Equal.sym(Nat, SC.length(M.Node<K>, PR.wr_nl(K, nl, id, node)), SC.length(M.Node<K>, nl), len_wr(K, nl, id, node)) : {Bool.and(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), _)))) == True{} : Bool}
      g_m

def write_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +node: M.Node<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.write(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id, node) == ST.real(~K, ~V, ~cmp, MI.write(~K, ~V, ~cmp, m, id, node)) : M.TreeMap<K, V, cmp>}:
  match m:
    case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl}:
      PR.write_c(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, L.and_left(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), id, node)

def exchange_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +value: Maybe<&2, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, V>, MI.exchange(~K, ~V, ~cmp, m, id, value)) == True{} : Bool}:
  match m:
    case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl}:
      %Equal.sym(Nat, SC.length(Maybe<&2, V>, PR.ex_pl(V, pl, id, value)), SC.length(Maybe<&2, V>, pl), len_ex(V, pl, id, value)) : {Bool.and(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(_, SC.length(M.Node<K>, nl))))) == True{} : Bool}
      g_m

def exchange_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +value: Maybe<&2, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.exchange(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id, value) == MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.exchange(~K, ~V, ~cmp, m, id, value)) : M.TreeMap<K, V, cmp> & Maybe<&2, V>}:
  match m:
    case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl}:
      PR.exchange_c(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, L.and_left(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), id, value)

def clear_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.clear(~K, ~V, ~cmp, m)) == True{} : Bool}:
  match m:
    case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl}:
      L.and_intro(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(0n, SC.pow2(d)), True{})), L.and_left(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m), L.and_intro(Nat.is_le(d, l), Bool.and(Nat.is_le(0n, SC.pow2(d)), True{}), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m)), L.and_intro(Nat.is_le(0n, SC.pow2(d)), True{}, N.zero_le(SC.pow2(d)), {==})))

def clear_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.clear(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)) == ST.real(~K, ~V, ~cmp, MI.clear(~K, ~V, ~cmp, m)) : M.TreeMap<K, V, cmp>}:
  match m:
    case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl}:
      %Equal.sym(M.NodeStore<K>, M.ns_clear(~K, ST.nodes(~K, l, d, nl)), ST.nodes(~K, l, d, Nil{}), NSL.ns_clear_ok(~K, l, d, nl, L.and_left(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))))) : {M.TM{0n, 0n, 0n, 0n, 0n, _, D.clear_at(~Maybe<&2, V>, ST.pays(~V, l, d, pl))} == ST.real(~K, ~V, ~cmp, ST.SH{0n, 0n, 0n, 0n, 0n, l, d, Nil{}, Nil{}, t, fl}) : M.TreeMap<K, V, cmp>}
      %Equal.sym(D.DynArray<&2, Maybe<&2, V>>, D.clear_at(~Maybe<&2, V>, ST.pays(~V, l, d, pl)), DAS.real(Maybe<&2, V>, DAS.Sh{l, d, 0n, MK.mk(Maybe<&2, V>, d, Nil{})}), AB.blk_clear(~Maybe<&2, V>, l, d, pl, L.and_left(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m)), L.subst(Nat, z => {Nat.is_le(z, SC.pow2(d)) == True{} : Bool}, SC.length(M.Node<K>, nl), SC.length(Maybe<&2, V>, pl), Equal.sym(Nat, SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl), N.eq_from_is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl), L.and_right(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))))), L.and_left(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m)))))) : {M.TM{0n, 0n, 0n, 0n, 0n, ST.nodes(~K, l, d, Nil{}), _} == ST.real(~K, ~V, ~cmp, ST.SH{0n, 0n, 0n, 0n, 0n, l, d, Nil{}, Nil{}, t, fl}) : M.TreeMap<K, V, cmp>}
      {==}

# ---- append ----


def lt_pl(~K: Data, ~V: Data, +nl: List<&2, M.Node<K>>, +pl: List<&2, Maybe<&2, V>>, +x: Nat, +b: Bool, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)) == True{} : Bool}, +h: {Nat.is_lt(SC.length(M.Node<K>, nl), x) == b : Bool}) -> {Nat.is_lt(SC.length(Maybe<&2, V>, pl), x) == b : Bool}:
  L.subst(Nat, z => {Nat.is_lt(z, x) == b : Bool}, SC.length(M.Node<K>, nl), SC.length(Maybe<&2, V>, pl), Equal.sym(Nat, SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl), N.eq_from_is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl), hp)), h)

def le_pl(~K: Data, ~V: Data, +nl: List<&2, M.Node<K>>, +pl: List<&2, Maybe<&2, V>>, +x: Nat, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)) == True{} : Bool}, +h: {Nat.is_le(SC.length(M.Node<K>, nl), x) == True{} : Bool}) -> {Nat.is_le(SC.length(Maybe<&2, V>, pl), x) == True{} : Bool}:
  L.subst(Nat, z => {Nat.is_le(z, x) == True{} : Bool}, SC.length(M.Node<K>, nl), SC.length(Maybe<&2, V>, pl), Equal.sym(Nat, SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl), N.eq_from_is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl), hp)), h)

def app_g(~K: Data, ~V: Data, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +k: K, +v: V, +p: Nat, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)) == True{} : Bool}, +room: Bool, +hr: {Nat.is_lt(SC.length(M.Node<K>, nl), SC.pow2(d)) == room : Bool}, +grow: Bool, +hgr: {Nat.is_lt(d, l) == grow : Bool}) -> {MI.dgp(K, V, Result<&2, &2, M.Rejected<K, V>, Nat>, MI.app_room(~K, ~V, n, root, lo, hi, free, l, d, nl, pl, t, fl, k, v, p, room, grow)) == True{} : Bool}:
  match room grow:
    case True{} _:
      %Equal.sym(Nat, SC.length(M.Node<K>, SC.snoc(M.Node<K>, nl, M.N{True{}, 0n, 0n, p, k})), 1n+SC.length(M.Node<K>, nl), LL.length_snoc(M.Node<K>, nl, M.N{True{}, 0n, 0n, p, k})) : {Bool.and(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(_, SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, SC.snoc(Maybe<&2, V>, pl, Some{v})), SC.length(M.Node<K>, SC.snoc(M.Node<K>, nl, M.N{True{}, 0n, 0n, p, k})))))) == True{} : Bool}
      %Equal.sym(Nat, SC.length(M.Node<K>, SC.snoc(M.Node<K>, nl, M.N{True{}, 0n, 0n, p, k})), 1n+SC.length(M.Node<K>, nl), LL.length_snoc(M.Node<K>, nl, M.N{True{}, 0n, 0n, p, k})) : {Bool.and(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(1n+SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, SC.snoc(Maybe<&2, V>, pl, Some{v})), _)))) == True{} : Bool}
      %Equal.sym(Nat, SC.length(Maybe<&2, V>, SC.snoc(Maybe<&2, V>, pl, Some{v})), 1n+SC.length(Maybe<&2, V>, pl), LL.length_snoc(Maybe<&2, V>, pl, Some{v})) : {Bool.and(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(1n+SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(_, 1n+SC.length(M.Node<K>, nl))))) == True{} : Bool}
      L.and_intro(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(1n+SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), hl, L.and_intro(Nat.is_le(d, l), Bool.and(Nat.is_le(1n+SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), hd, L.and_intro(Nat.is_le(1n+SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), N.lt_succ_le_succ(SC.length(M.Node<K>, nl), SC.pow2(d), hr), hp)))
    case False{} True{}:
      %Equal.sym(Nat, SC.length(M.Node<K>, SC.snoc(M.Node<K>, nl, M.N{True{}, 0n, 0n, p, k})), 1n+SC.length(M.Node<K>, nl), LL.length_snoc(M.Node<K>, nl, M.N{True{}, 0n, 0n, p, k})) : {Bool.and(Nat.is_le(l, 31n), Bool.and(Nat.is_le(1n+d, l), Bool.and(Nat.is_le(_, SC.pow2(1n+d)), Nat.is_eq(SC.length(Maybe<&2, V>, SC.snoc(Maybe<&2, V>, pl, Some{v})), SC.length(M.Node<K>, SC.snoc(M.Node<K>, nl, M.N{True{}, 0n, 0n, p, k})))))) == True{} : Bool}
      %Equal.sym(Nat, SC.length(M.Node<K>, SC.snoc(M.Node<K>, nl, M.N{True{}, 0n, 0n, p, k})), 1n+SC.length(M.Node<K>, nl), LL.length_snoc(M.Node<K>, nl, M.N{True{}, 0n, 0n, p, k})) : {Bool.and(Nat.is_le(l, 31n), Bool.and(Nat.is_le(1n+d, l), Bool.and(Nat.is_le(1n+SC.length(M.Node<K>, nl), SC.pow2(1n+d)), Nat.is_eq(SC.length(Maybe<&2, V>, SC.snoc(Maybe<&2, V>, pl, Some{v})), _)))) == True{} : Bool}
      %Equal.sym(Nat, SC.length(Maybe<&2, V>, SC.snoc(Maybe<&2, V>, pl, Some{v})), 1n+SC.length(Maybe<&2, V>, pl), LL.length_snoc(Maybe<&2, V>, pl, Some{v})) : {Bool.and(Nat.is_le(l, 31n), Bool.and(Nat.is_le(1n+d, l), Bool.and(Nat.is_le(1n+SC.length(M.Node<K>, nl), SC.pow2(1n+d)), Nat.is_eq(_, 1n+SC.length(M.Node<K>, nl))))) == True{} : Bool}
      +h3 = N.lt_succ_le_succ(SC.length(M.Node<K>, nl), SC.pow2(1n+d), N.le_lt_trans(SC.length(M.Node<K>, nl), SC.pow2(d), SC.pow2(1n+d), hc, N.pow2_lt_succ(d)))
      L.and_intro(Nat.is_le(l, 31n), Bool.and(Nat.is_le(1n+d, l), Bool.and(Nat.is_le(1n+SC.length(M.Node<K>, nl), SC.pow2(1n+d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), hl, L.and_intro(Nat.is_le(1n+d, l), Bool.and(Nat.is_le(1n+SC.length(M.Node<K>, nl), SC.pow2(1n+d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), N.lt_succ_le_succ(d, l, hgr), L.and_intro(Nat.is_le(1n+SC.length(M.Node<K>, nl), SC.pow2(1n+d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), h3, hp)))
    case False{} False{}:
      L.and_intro(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), hl, L.and_intro(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), hd, L.and_intro(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), hc, hp)))


def app_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +k: K, +v: V, +p: Nat, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)) == True{} : Bool}, +room: Bool, +hr: {Nat.is_lt(SC.length(M.Node<K>, nl), SC.pow2(d)) == room : Bool}, +grow: Bool, +hgr: {Nat.is_lt(d, l) == grow : Bool}) -> {M.append_nodes(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), k, v, 1n+SC.length(M.Node<K>, nl), M.ns_push(~K, ST.nodes(~K, l, d, nl), M.N{True{}, 0n, 0n, p, k})) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Nat>, MI.app_room(~K, ~V, n, root, lo, hi, free, l, d, nl, pl, t, fl, k, v, p, room, grow)) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Nat>}:
  match room grow:
    case True{} _:
      %Equal.sym(M.NodeStore<K> & Result<&2, &2, DE.Error, Unit>, M.ns_push(~K, ST.nodes(~K, l, d, nl), M.N{True{}, 0n, 0n, p, k}), (ST.nodes(~K, l, d, SC.snoc(M.Node<K>, nl, M.N{True{}, 0n, 0n, p, k})), Done{Unit{}}), NSL.ns_push_room(~K, l, d, nl, hl, hd, hc, M.N{True{}, 0n, 0n, p, k}, hr)) : {M.append_nodes(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), k, v, 1n+SC.length(M.Node<K>, nl), _) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Nat>, MI.app_room(~K, ~V, n, root, lo, hi, free, l, d, nl, pl, t, fl, k, v, p, True{}, grow)) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Nat>}
      %Equal.sym(D.DynArray<&2, Maybe<&2, V>> & Result<&2, &2, DE.Error, Unit>, D.push_at(~Maybe<&2, V>, ST.pays(~V, l, d, pl), Some{v}), (ST.pays(~V, l, d, SC.snoc(Maybe<&2, V>, pl, Some{v})), Done{Unit{}}), AB.blk_push_room(~Maybe<&2, V>, l, d, pl, hl, hd, le_pl(~K, ~V, nl, pl, SC.pow2(d), hp, hc), Some{v}, lt_pl(~K, ~V, nl, pl, SC.pow2(d), True{}, hp, hr))) : {M.append_values(~K, ~V, ~cmp, n, root, lo, hi, free, ST.nodes(~K, l, d, SC.snoc(M.Node<K>, nl, M.N{True{}, 0n, 0n, p, k})), k, v, 1n+SC.length(M.Node<K>, nl), _) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Nat>, MI.app_room(~K, ~V, n, root, lo, hi, free, l, d, nl, pl, t, fl, k, v, p, True{}, grow)) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Nat>}
      {==}
    case False{} True{}:
      %Equal.sym(M.NodeStore<K> & Result<&2, &2, DE.Error, Unit>, M.ns_push(~K, ST.nodes(~K, l, d, nl), M.N{True{}, 0n, 0n, p, k}), (ST.nodes(~K, l, 1n+d, SC.snoc(M.Node<K>, nl, M.N{True{}, 0n, 0n, p, k})), Done{Unit{}}), NSL.ns_push_grow(~K, l, d, nl, hl, hd, hc, M.N{True{}, 0n, 0n, p, k}, hr, hgr)) : {M.append_nodes(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), k, v, 1n+SC.length(M.Node<K>, nl), _) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Nat>, MI.app_room(~K, ~V, n, root, lo, hi, free, l, d, nl, pl, t, fl, k, v, p, False{}, True{})) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Nat>}
      %Equal.sym(D.DynArray<&2, Maybe<&2, V>> & Result<&2, &2, DE.Error, Unit>, D.push_at(~Maybe<&2, V>, ST.pays(~V, l, d, pl), Some{v}), (ST.pays(~V, l, 1n+d, SC.snoc(Maybe<&2, V>, pl, Some{v})), Done{Unit{}}), AB.blk_push_grow(~Maybe<&2, V>, l, d, pl, hl, hd, le_pl(~K, ~V, nl, pl, SC.pow2(d), hp, hc), Some{v}, lt_pl(~K, ~V, nl, pl, SC.pow2(d), False{}, hp, hr), hgr)) : {M.append_values(~K, ~V, ~cmp, n, root, lo, hi, free, ST.nodes(~K, l, 1n+d, SC.snoc(M.Node<K>, nl, M.N{True{}, 0n, 0n, p, k})), k, v, 1n+SC.length(M.Node<K>, nl), _) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Nat>, MI.app_room(~K, ~V, n, root, lo, hi, free, l, d, nl, pl, t, fl, k, v, p, False{}, True{})) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Nat>}
      {==}
    case False{} False{}:
      %Equal.sym(M.NodeStore<K> & Result<&2, &2, DE.Error, Unit>, M.ns_push(~K, ST.nodes(~K, l, d, nl), M.N{True{}, 0n, 0n, p, k}), (ST.nodes(~K, l, d, nl), Fail{DE.CapacityExceeded{}}), NSL.ns_push_full(~K, l, d, nl, hl, hd, hc, M.N{True{}, 0n, 0n, p, k}, hr, hgr)) : {M.append_nodes(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), k, v, 1n+SC.length(M.Node<K>, nl), _) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Nat>, MI.app_room(~K, ~V, n, root, lo, hi, free, l, d, nl, pl, t, fl, k, v, p, False{}, False{})) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Nat>}
      {==}

def append_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +v: V, +p: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Result<&2, &2, M.Rejected<K, V>, Nat>, MI.append(~K, ~V, ~cmp, m, k, v, p)) == True{} : Bool}:
  match m:
    case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl}:
      app_g(~K, ~V, n, root, lo, hi, free, l, d, nl, pl, t, fl, k, v, p, L.and_left(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), Nat.is_lt(SC.length(M.Node<K>, nl), SC.pow2(d)), {==}, Nat.is_lt(d, l), {==})

def append_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +v: V, +p: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.append(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k, v, p) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Nat>, MI.append(~K, ~V, ~cmp, m, k, v, p)) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Nat>}:
  match m:
    case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl}:
      app_s(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, k, v, p, L.and_left(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), Nat.is_lt(SC.length(M.Node<K>, nl), SC.pow2(d)), {==}, Nat.is_lt(d, l), {==})


# ---- field writes: the mirror keeps the layout ----

def set_left_node_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +v: Nat, +node: M.Node<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.set_left_node(~K, ~V, ~cmp, m, id, v, node)) == True{} : Bool}:
  match node:
    case M.Free{+px2}:
      g_m
    case M.N{+px3, +px4, +px5, +px6, +px7}:
      write_g(~K, ~V, ~cmp, m, id, M.N{px3, v, px5, px6, px7}, g_m)

def set_left_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +v: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dg(K, V, MI.set_left_1(~K, ~V, ~cmp, id, v, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m1, +node}:
      set_left_node_g(~K, ~V, ~cmp, m1, id, v, node, g_pair_result)

def set_left_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +v: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.set_left(~K, ~V, ~cmp, m, id, v)) == True{} : Bool}:
  set_left_1_g(~K, ~V, ~cmp, id, v, MI.read(~K, ~V, ~cmp, m, id), read_g(~K, ~V, ~cmp, m, id, g_m))

def set_right_node_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +v: Nat, +node: M.Node<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.set_right_node(~K, ~V, ~cmp, m, id, v, node)) == True{} : Bool}:
  match node:
    case M.Free{+px2}:
      g_m
    case M.N{+px3, +px4, +px5, +px6, +px7}:
      write_g(~K, ~V, ~cmp, m, id, M.N{px3, px4, v, px6, px7}, g_m)

def set_right_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +v: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dg(K, V, MI.set_right_1(~K, ~V, ~cmp, id, v, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m1, +node}:
      set_right_node_g(~K, ~V, ~cmp, m1, id, v, node, g_pair_result)

def set_right_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +v: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.set_right(~K, ~V, ~cmp, m, id, v)) == True{} : Bool}:
  set_right_1_g(~K, ~V, ~cmp, id, v, MI.read(~K, ~V, ~cmp, m, id), read_g(~K, ~V, ~cmp, m, id, g_m))

def set_parent_node_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +v: Nat, +node: M.Node<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.set_parent_node(~K, ~V, ~cmp, m, id, v, node)) == True{} : Bool}:
  match node:
    case M.Free{+px2}:
      g_m
    case M.N{+px3, +px4, +px5, +px6, +px7}:
      write_g(~K, ~V, ~cmp, m, id, M.N{px3, px4, px5, v, px7}, g_m)

def set_parent_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +v: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dg(K, V, MI.set_parent_1(~K, ~V, ~cmp, id, v, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m1, +node}:
      set_parent_node_g(~K, ~V, ~cmp, m1, id, v, node, g_pair_result)

def set_parent_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +v: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.set_parent(~K, ~V, ~cmp, m, id, v)) == True{} : Bool}:
  set_parent_1_g(~K, ~V, ~cmp, id, v, MI.read(~K, ~V, ~cmp, m, id), read_g(~K, ~V, ~cmp, m, id, g_m))

def set_red_node_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +v: Bool, +node: M.Node<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.set_red_node(~K, ~V, ~cmp, m, id, v, node)) == True{} : Bool}:
  match node:
    case M.Free{+px2}:
      g_m
    case M.N{+px3, +px4, +px5, +px6, +px7}:
      write_g(~K, ~V, ~cmp, m, id, M.N{v, px4, px5, px6, px7}, g_m)

def set_red_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +v: Bool, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dg(K, V, MI.set_red_1(~K, ~V, ~cmp, id, v, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m1, +node}:
      set_red_node_g(~K, ~V, ~cmp, m1, id, v, node, g_pair_result)

def set_red_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +v: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.set_red(~K, ~V, ~cmp, m, id, v)) == True{} : Bool}:
  set_red_1_g(~K, ~V, ~cmp, id, v, MI.read(~K, ~V, ~cmp, m, id), read_g(~K, ~V, ~cmp, m, id, g_m))


# ---- field writes: one array written is the node written ----

def set_left_sc(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)) == True{} : Bool}, +i: Nat, +v: Nat, +y: M.Node<K>, +hy: {ST.nth_or(M.Node<K>, nl, i, M.Free{0n}) == y : M.Node<K>}) -> {M.TM{n, root, lo, hi, free, M.ns_set_left(~K, ST.nodes(~K, l, d, nl), i, v), ST.pays(~V, l, d, pl)} == ST.real(~K, ~V, ~cmp, MI.set_left_node(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, 1n+i, v, y)) : M.TreeMap<K, V, cmp>}:
  match y:
    case M.Free{+z}:
      %Equal.sym(M.NodeStore<K>, M.ns_set_left(~K, ST.nodes(~K, l, d, nl), i, v), ST.nodes(~K, l, d, nl), NSL.left_set_free(~K, l, d, nl, hl, hd, hc, i, v, z, hy)) : {M.TM{n, root, lo, hi, free, _, ST.pays(~V, l, d, pl)} == ST.real(~K, ~V, ~cmp, MI.set_left_node(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, 1n+i, v, M.Free{z})) : M.TreeMap<K, V, cmp>}
      {==}
    case M.N{+c, +lf, +rt, +q, +k}:
      +hlt = NSL.nth_or_lt(~K, nl, i, M.N{c, lf, rt, q, k}, {==}, hy)
      %Equal.sym(M.NodeStore<K>, M.ns_set_left(~K, ST.nodes(~K, l, d, nl), i, v), ST.nodes(~K, l, d, SC.update(M.Node<K>, nl, i, M.N{c, v, rt, q, k})), NSL.left_set_node(~K, l, d, nl, hl, hd, hc, i, v, c, lf, rt, q, k, hy)) : {M.TM{n, root, lo, hi, free, _, ST.pays(~V, l, d, pl)} == ST.real(~K, ~V, ~cmp, MI.set_left_node(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, 1n+i, v, M.N{c, lf, rt, q, k})) : M.TreeMap<K, V, cmp>}
      %Equal.sym(Bool, Nat.is_lt(i, SC.length(M.Node<K>, nl)), True{}, hlt) : {M.TM{n, root, lo, hi, free, ST.nodes(~K, l, d, SC.update(M.Node<K>, nl, i, M.N{c, v, rt, q, k})), ST.pays(~V, l, d, pl)} == ST.real(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, ST.pk(List<&2, M.Node<K>>, _, SC.update(M.Node<K>, nl, i, M.N{c, v, rt, q, k}), nl), pl, t, fl}) : M.TreeMap<K, V, cmp>}
      {==}

def set_left_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +v: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.set_left(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id, v) == ST.real(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m, id, v)) : M.TreeMap<K, V, cmp>}:
  match m id:
    case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl} 0n:
      {==}
    case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl} 1n+ +i:
      set_left_sc(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, L.and_left(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), i, v, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}), {==})

def set_right_sc(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)) == True{} : Bool}, +i: Nat, +v: Nat, +y: M.Node<K>, +hy: {ST.nth_or(M.Node<K>, nl, i, M.Free{0n}) == y : M.Node<K>}) -> {M.TM{n, root, lo, hi, free, M.ns_set_right(~K, ST.nodes(~K, l, d, nl), i, v), ST.pays(~V, l, d, pl)} == ST.real(~K, ~V, ~cmp, MI.set_right_node(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, 1n+i, v, y)) : M.TreeMap<K, V, cmp>}:
  match y:
    case M.Free{+z}:
      %Equal.sym(M.NodeStore<K>, M.ns_set_right(~K, ST.nodes(~K, l, d, nl), i, v), ST.nodes(~K, l, d, nl), NSL.right_set_free(~K, l, d, nl, hl, hd, hc, i, v, z, hy)) : {M.TM{n, root, lo, hi, free, _, ST.pays(~V, l, d, pl)} == ST.real(~K, ~V, ~cmp, MI.set_right_node(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, 1n+i, v, M.Free{z})) : M.TreeMap<K, V, cmp>}
      {==}
    case M.N{+c, +lf, +rt, +q, +k}:
      +hlt = NSL.nth_or_lt(~K, nl, i, M.N{c, lf, rt, q, k}, {==}, hy)
      %Equal.sym(M.NodeStore<K>, M.ns_set_right(~K, ST.nodes(~K, l, d, nl), i, v), ST.nodes(~K, l, d, SC.update(M.Node<K>, nl, i, M.N{c, lf, v, q, k})), NSL.right_set_node(~K, l, d, nl, hl, hd, hc, i, v, c, lf, rt, q, k, hy)) : {M.TM{n, root, lo, hi, free, _, ST.pays(~V, l, d, pl)} == ST.real(~K, ~V, ~cmp, MI.set_right_node(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, 1n+i, v, M.N{c, lf, rt, q, k})) : M.TreeMap<K, V, cmp>}
      %Equal.sym(Bool, Nat.is_lt(i, SC.length(M.Node<K>, nl)), True{}, hlt) : {M.TM{n, root, lo, hi, free, ST.nodes(~K, l, d, SC.update(M.Node<K>, nl, i, M.N{c, lf, v, q, k})), ST.pays(~V, l, d, pl)} == ST.real(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, ST.pk(List<&2, M.Node<K>>, _, SC.update(M.Node<K>, nl, i, M.N{c, lf, v, q, k}), nl), pl, t, fl}) : M.TreeMap<K, V, cmp>}
      {==}

def set_right_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +v: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.set_right(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id, v) == ST.real(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m, id, v)) : M.TreeMap<K, V, cmp>}:
  match m id:
    case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl} 0n:
      {==}
    case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl} 1n+ +i:
      set_right_sc(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, L.and_left(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), i, v, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}), {==})

def set_parent_sc(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)) == True{} : Bool}, +i: Nat, +v: Nat, +y: M.Node<K>, +hy: {ST.nth_or(M.Node<K>, nl, i, M.Free{0n}) == y : M.Node<K>}) -> {M.TM{n, root, lo, hi, free, M.ns_set_parent(~K, ST.nodes(~K, l, d, nl), i, v), ST.pays(~V, l, d, pl)} == ST.real(~K, ~V, ~cmp, MI.set_parent_node(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, 1n+i, v, y)) : M.TreeMap<K, V, cmp>}:
  match y:
    case M.Free{+z}:
      %Equal.sym(M.NodeStore<K>, M.ns_set_parent(~K, ST.nodes(~K, l, d, nl), i, v), ST.nodes(~K, l, d, nl), NSL.parent_set_free(~K, l, d, nl, hl, hd, hc, i, v, z, hy)) : {M.TM{n, root, lo, hi, free, _, ST.pays(~V, l, d, pl)} == ST.real(~K, ~V, ~cmp, MI.set_parent_node(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, 1n+i, v, M.Free{z})) : M.TreeMap<K, V, cmp>}
      {==}
    case M.N{+c, +lf, +rt, +q, +k}:
      +hlt = NSL.nth_or_lt(~K, nl, i, M.N{c, lf, rt, q, k}, {==}, hy)
      %Equal.sym(M.NodeStore<K>, M.ns_set_parent(~K, ST.nodes(~K, l, d, nl), i, v), ST.nodes(~K, l, d, SC.update(M.Node<K>, nl, i, M.N{c, lf, rt, v, k})), NSL.parent_set_node(~K, l, d, nl, hl, hd, hc, i, v, c, lf, rt, q, k, hy)) : {M.TM{n, root, lo, hi, free, _, ST.pays(~V, l, d, pl)} == ST.real(~K, ~V, ~cmp, MI.set_parent_node(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, 1n+i, v, M.N{c, lf, rt, q, k})) : M.TreeMap<K, V, cmp>}
      %Equal.sym(Bool, Nat.is_lt(i, SC.length(M.Node<K>, nl)), True{}, hlt) : {M.TM{n, root, lo, hi, free, ST.nodes(~K, l, d, SC.update(M.Node<K>, nl, i, M.N{c, lf, rt, v, k})), ST.pays(~V, l, d, pl)} == ST.real(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, ST.pk(List<&2, M.Node<K>>, _, SC.update(M.Node<K>, nl, i, M.N{c, lf, rt, v, k}), nl), pl, t, fl}) : M.TreeMap<K, V, cmp>}
      {==}

def set_parent_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +v: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.set_parent(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id, v) == ST.real(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, m, id, v)) : M.TreeMap<K, V, cmp>}:
  match m id:
    case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl} 0n:
      {==}
    case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl} 1n+ +i:
      set_parent_sc(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, L.and_left(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), i, v, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}), {==})

def set_red_sc(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)) == True{} : Bool}, +i: Nat, +v: Bool, +y: M.Node<K>, +hy: {ST.nth_or(M.Node<K>, nl, i, M.Free{0n}) == y : M.Node<K>}) -> {M.TM{n, root, lo, hi, free, M.ns_set_red(~K, ST.nodes(~K, l, d, nl), i, v), ST.pays(~V, l, d, pl)} == ST.real(~K, ~V, ~cmp, MI.set_red_node(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, 1n+i, v, y)) : M.TreeMap<K, V, cmp>}:
  match y:
    case M.Free{+z}:
      %Equal.sym(M.NodeStore<K>, M.ns_set_red(~K, ST.nodes(~K, l, d, nl), i, v), ST.nodes(~K, l, d, nl), NSL.red_set_free(~K, l, d, nl, hl, hd, hc, i, v, z, hy)) : {M.TM{n, root, lo, hi, free, _, ST.pays(~V, l, d, pl)} == ST.real(~K, ~V, ~cmp, MI.set_red_node(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, 1n+i, v, M.Free{z})) : M.TreeMap<K, V, cmp>}
      {==}
    case M.N{+c, +lf, +rt, +q, +k}:
      +hlt = NSL.nth_or_lt(~K, nl, i, M.N{c, lf, rt, q, k}, {==}, hy)
      %Equal.sym(M.NodeStore<K>, M.ns_set_red(~K, ST.nodes(~K, l, d, nl), i, v), ST.nodes(~K, l, d, SC.update(M.Node<K>, nl, i, M.N{v, lf, rt, q, k})), NSL.red_set_node(~K, l, d, nl, hl, hd, hc, i, v, c, lf, rt, q, k, hy)) : {M.TM{n, root, lo, hi, free, _, ST.pays(~V, l, d, pl)} == ST.real(~K, ~V, ~cmp, MI.set_red_node(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, 1n+i, v, M.N{c, lf, rt, q, k})) : M.TreeMap<K, V, cmp>}
      %Equal.sym(Bool, Nat.is_lt(i, SC.length(M.Node<K>, nl)), True{}, hlt) : {M.TM{n, root, lo, hi, free, ST.nodes(~K, l, d, SC.update(M.Node<K>, nl, i, M.N{v, lf, rt, q, k})), ST.pays(~V, l, d, pl)} == ST.real(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, ST.pk(List<&2, M.Node<K>>, _, SC.update(M.Node<K>, nl, i, M.N{v, lf, rt, q, k}), nl), pl, t, fl}) : M.TreeMap<K, V, cmp>}
      {==}

def set_red_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +v: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id, v) == ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, id, v)) : M.TreeMap<K, V, cmp>}:
  match m id:
    case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl} 0n:
      {==}
    case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl} 1n+ +i:
      set_red_sc(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, L.and_left(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), i, v, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}), {==})

# ---- the neighbour walks: field reads are the node list's ----


def side_ok(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)) == True{} : Bool}, +left: Bool, +i: Nat) -> {M.side_at(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), left, i) == (ST.nodes(~K, l, d, nl), M.pick(Nat, left, M.nleft(~K, ST.nth_or(M.Node<K>, nl, i, M.Free{0n})), M.nright(~K, ST.nth_or(M.Node<K>, nl, i, M.Free{0n})))) : M.NodeStore<K> & Nat}:
  match left:
    case True{}:
      NSL.left_at_ok(~K, l, d, nl, hl, hd, hc, i)
    case False{}:
      NSL.right_at_ok(~K, l, d, nl, hl, hd, hc, i)

def asc_y(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)) == True{} : Bool}, +x: Nat, +i: Nat, +forward: Bool, +y: M.Node<K>, +hy: {ST.nth_or(M.Node<K>, nl, i, M.Free{0n}) == y : M.Node<K>}) -> {M.ascend_tag(~K, ~V, ~cmp, x, 1n+i, i, forward, (ST.nodes(~K, l, d, nl), M.ntag(~K, y))) == (ST.nodes(~K, l, d, nl), MI.asc_step(K, x, 1n+i, forward, y)) : M.NodeStore<K> & M.Ascend}:
  match y:
    case M.Free{z}:
      {==}
    case M.N{True{}, +lf, +rt, +q, +k}:
      %Equal.sym(M.NodeStore<K> & Nat, M.side_at(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), forward, i), (ST.nodes(~K, l, d, nl), M.pick(Nat, forward, M.nleft(~K, ST.nth_or(M.Node<K>, nl, i, M.Free{0n})), M.nright(~K, ST.nth_or(M.Node<K>, nl, i, M.Free{0n})))), side_ok(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, forward, i)) : {M.ascend_side(~K, ~V, ~cmp, x, 1n+i, i, _) == (ST.nodes(~K, l, d, nl), MI.asc_step(K, x, 1n+i, forward, M.N{True{}, lf, rt, q, k})) : M.NodeStore<K> & M.Ascend}
      %Equal.sym(M.NodeStore<K> & Nat, M.ns_parent_at(~K, ST.nodes(~K, l, d, nl), i), (ST.nodes(~K, l, d, nl), M.nparent(~K, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}))), NSL.parent_at_ok(~K, l, d, nl, hl, hd, hc, i)) : {M.ascend_par(~K, ~V, ~cmp, x, 1n+i, M.pick(Nat, forward, M.nleft(~K, ST.nth_or(M.Node<K>, nl, i, M.Free{0n})), M.nright(~K, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}))), _) == (ST.nodes(~K, l, d, nl), MI.asc_step(K, x, 1n+i, forward, M.N{True{}, lf, rt, q, k})) : M.NodeStore<K> & M.Ascend}
      %Equal.sym(M.Node<K>, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}), M.N{True{}, lf, rt, q, k}, hy) : {(ST.nodes(~K, l, d, nl), M.ascend_choice(1n+i, 1n+i, M.nparent(~K, _), Nat.is_eq(x, M.pick(Nat, forward, M.nleft(~K, _), M.nright(~K, _))))) == (ST.nodes(~K, l, d, nl), MI.asc_step(K, x, 1n+i, forward, M.N{True{}, lf, rt, q, k})) : M.NodeStore<K> & M.Ascend}
      {==}
    case M.N{False{}, +lf, +rt, +q, +k}:
      %Equal.sym(M.NodeStore<K> & Nat, M.side_at(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), forward, i), (ST.nodes(~K, l, d, nl), M.pick(Nat, forward, M.nleft(~K, ST.nth_or(M.Node<K>, nl, i, M.Free{0n})), M.nright(~K, ST.nth_or(M.Node<K>, nl, i, M.Free{0n})))), side_ok(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, forward, i)) : {M.ascend_side(~K, ~V, ~cmp, x, 1n+i, i, _) == (ST.nodes(~K, l, d, nl), MI.asc_step(K, x, 1n+i, forward, M.N{False{}, lf, rt, q, k})) : M.NodeStore<K> & M.Ascend}
      %Equal.sym(M.NodeStore<K> & Nat, M.ns_parent_at(~K, ST.nodes(~K, l, d, nl), i), (ST.nodes(~K, l, d, nl), M.nparent(~K, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}))), NSL.parent_at_ok(~K, l, d, nl, hl, hd, hc, i)) : {M.ascend_par(~K, ~V, ~cmp, x, 1n+i, M.pick(Nat, forward, M.nleft(~K, ST.nth_or(M.Node<K>, nl, i, M.Free{0n})), M.nright(~K, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}))), _) == (ST.nodes(~K, l, d, nl), MI.asc_step(K, x, 1n+i, forward, M.N{False{}, lf, rt, q, k})) : M.NodeStore<K> & M.Ascend}
      %Equal.sym(M.Node<K>, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}), M.N{False{}, lf, rt, q, k}, hy) : {(ST.nodes(~K, l, d, nl), M.ascend_choice(1n+i, 1n+i, M.nparent(~K, _), Nat.is_eq(x, M.pick(Nat, forward, M.nleft(~K, _), M.nright(~K, _))))) == (ST.nodes(~K, l, d, nl), MI.asc_step(K, x, 1n+i, forward, M.N{False{}, lf, rt, q, k})) : M.NodeStore<K> & M.Ascend}
      {==}

# one ascending step reads the node's tag, child and parent
def asc_at(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)) == True{} : Bool}, +x: Nat, +p: Nat, +forward: Bool) -> {M.ascend_at(~K, ~V, ~cmp, x, p, forward, ST.nodes(~K, l, d, nl)) == (ST.nodes(~K, l, d, nl), MI.asc_step(K, x, p, forward, ST.nd(K, nl, p))) : M.NodeStore<K> & M.Ascend}:
  match p:
    case 0n:
      {==}
    case 1n+ +i:
      %Equal.sym(M.NodeStore<K> & Nat, M.ns_tag_at(~K, ST.nodes(~K, l, d, nl), i), (ST.nodes(~K, l, d, nl), M.ntag(~K, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}))), NSL.tag_at_ok(~K, l, d, nl, hl, hd, hc, i)) : {M.ascend_tag(~K, ~V, ~cmp, x, 1n+i, i, forward, _) == (ST.nodes(~K, l, d, nl), MI.asc_step(K, x, 1n+i, forward, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}))) : M.NodeStore<K> & M.Ascend}
      asc_y(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, x, i, forward, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}), {==})

def ext_pick(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, -a: M.NodeStore<K>, +fw: Bool, +lf: Nat, +rt: Nat) -> {(a, M.pick(Nat, Bool.not(fw), lf, rt)) == (a, M.pick(Nat, fw, rt, lf)) : M.NodeStore<K> & Nat}:
  match fw:
    case True{}:
      {==}
    case False{}:
      {==}

def ext_free(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, -a: M.NodeStore<K>, +forward: Bool, +z: Nat) -> {(a, 0n) == (a, M.child(~K, M.Free{z}, forward)) : M.NodeStore<K> & Nat}:
  match forward:
    case True{}:
      {==}
    case False{}:
      {==}

def ext_y(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)) == True{} : Bool}, +forward: Bool, +j: Nat, +y: M.Node<K>, +hy: {ST.nth_or(M.Node<K>, nl, j, M.Free{0n}) == y : M.Node<K>}) -> {M.extreme_tag(~K, ~V, ~cmp, forward, j, (ST.nodes(~K, l, d, nl), M.ntag(~K, y))) == (ST.nodes(~K, l, d, nl), M.child(~K, y, forward)) : M.NodeStore<K> & Nat}:
  match y:
    case M.Free{+z}:
      ext_free(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), forward, z)
    case M.N{True{}, +lf, +rt, +q, +k}:
      %Equal.sym(M.NodeStore<K> & Nat, M.side_at(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), Bool.not(forward), j), (ST.nodes(~K, l, d, nl), M.pick(Nat, Bool.not(forward), M.nleft(~K, ST.nth_or(M.Node<K>, nl, j, M.Free{0n})), M.nright(~K, ST.nth_or(M.Node<K>, nl, j, M.Free{0n})))), side_ok(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, Bool.not(forward), j)) : {_ == (ST.nodes(~K, l, d, nl), M.child(~K, M.N{True{}, lf, rt, q, k}, forward)) : M.NodeStore<K> & Nat}
      %Equal.sym(M.Node<K>, ST.nth_or(M.Node<K>, nl, j, M.Free{0n}), M.N{True{}, lf, rt, q, k}, hy) : {(ST.nodes(~K, l, d, nl), M.pick(Nat, Bool.not(forward), M.nleft(~K, _), M.nright(~K, _))) == (ST.nodes(~K, l, d, nl), M.child(~K, M.N{True{}, lf, rt, q, k}, forward)) : M.NodeStore<K> & Nat}
      ext_pick(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), forward, lf, rt)
    case M.N{False{}, +lf, +rt, +q, +k}:
      %Equal.sym(M.NodeStore<K> & Nat, M.side_at(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), Bool.not(forward), j), (ST.nodes(~K, l, d, nl), M.pick(Nat, Bool.not(forward), M.nleft(~K, ST.nth_or(M.Node<K>, nl, j, M.Free{0n})), M.nright(~K, ST.nth_or(M.Node<K>, nl, j, M.Free{0n})))), side_ok(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, Bool.not(forward), j)) : {_ == (ST.nodes(~K, l, d, nl), M.child(~K, M.N{False{}, lf, rt, q, k}, forward)) : M.NodeStore<K> & Nat}
      %Equal.sym(M.Node<K>, ST.nth_or(M.Node<K>, nl, j, M.Free{0n}), M.N{False{}, lf, rt, q, k}, hy) : {(ST.nodes(~K, l, d, nl), M.pick(Nat, Bool.not(forward), M.nleft(~K, _), M.nright(~K, _))) == (ST.nodes(~K, l, d, nl), M.child(~K, M.N{False{}, lf, rt, q, k}, forward)) : M.NodeStore<K> & Nat}
      ext_pick(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), forward, lf, rt)

# one descending step reads the node's tag and one child
def ext_at(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)) == True{} : Bool}, +forward: Bool, +j: Nat) -> {M.extreme_at(~K, ~V, ~cmp, forward, ST.nodes(~K, l, d, nl), j) == (ST.nodes(~K, l, d, nl), M.child(~K, ST.nth_or(M.Node<K>, nl, j, M.Free{0n}), forward)) : M.NodeStore<K> & Nat}:
  %Equal.sym(M.NodeStore<K> & Nat, M.ns_tag_at(~K, ST.nodes(~K, l, d, nl), j), (ST.nodes(~K, l, d, nl), M.ntag(~K, ST.nth_or(M.Node<K>, nl, j, M.Free{0n}))), NSL.tag_at_ok(~K, l, d, nl, hl, hd, hc, j)) : {M.extreme_tag(~K, ~V, ~cmp, forward, j, _) == (ST.nodes(~K, l, d, nl), M.child(~K, ST.nth_or(M.Node<K>, nl, j, M.Free{0n}), forward)) : M.NodeStore<K> & Nat}
  ext_y(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, forward, j, ST.nth_or(M.Node<K>, nl, j, M.Free{0n}), {==})

def asl(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)) == True{} : Bool}, +fuel: Nat, +forward: Bool, +st: M.Ascend) -> {M.ascend_slots_loop(~K, ~V, ~cmp, fuel, forward, (ST.nodes(~K, l, d, nl), st)) == (ST.nodes(~K, l, d, nl), MI.asc_loop(K, fuel, nl, forward, st)) : M.NodeStore<K> & Nat}:
  match fuel st:
    case 0n _:
      {==}
    case 1n+f M.Ascend{x, p, True{}}:
      {==}
    case 1n+f M.Ascend{+x, +p, False{}}:
      %Equal.sym(M.NodeStore<K> & M.Ascend, M.ascend_at(~K, ~V, ~cmp, x, p, forward, ST.nodes(~K, l, d, nl)), (ST.nodes(~K, l, d, nl), MI.asc_step(K, x, p, forward, ST.nd(K, nl, p))), asc_at(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, x, p, forward)) : {M.ascend_slots_loop(~K, ~V, ~cmp, f, forward, _) == (ST.nodes(~K, l, d, nl), MI.asc_loop(K, 1n+f, nl, forward, M.Ascend{x, p, False{}})) : M.NodeStore<K> & Nat}
      asl(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, f, forward, MI.asc_step(K, x, p, forward, ST.nd(K, nl, p)))

def esl(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)) == True{} : Bool}, +fuel: Nat, +forward: Bool, +id: Nat, +next: Nat) -> {M.extreme_slots_loop(~K, ~V, ~cmp, fuel, forward, id, (ST.nodes(~K, l, d, nl), next)) == (ST.nodes(~K, l, d, nl), MI.ext_loop(~K, fuel, nl, forward, id, next)) : M.NodeStore<K> & Nat}:
  match fuel next:
    case 0n _:
      {==}
    case 1n+f 0n:
      {==}
    case 1n+f 1n+ +j:
      %Equal.sym(M.NodeStore<K> & Nat, M.extreme_at(~K, ~V, ~cmp, forward, ST.nodes(~K, l, d, nl), j), (ST.nodes(~K, l, d, nl), M.child(~K, ST.nth_or(M.Node<K>, nl, j, M.Free{0n}), forward)), ext_at(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, forward, j)) : {M.extreme_slots_loop(~K, ~V, ~cmp, f, forward, 1n+j, _) == (ST.nodes(~K, l, d, nl), MI.ext_loop(~K, 1n+f, nl, forward, id, 1n+j)) : M.NodeStore<K> & Nat}
      esl(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, f, forward, 1n+j, M.child(~K, ST.nth_or(M.Node<K>, nl, j, M.Free{0n}), forward))

def nbl(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)) == True{} : Bool}, +n: Nat, +id: Nat, +p: Nat, +forward: Bool, +c: Nat) -> {M.neighbor_slots(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), n, id, p, forward, c) == (ST.nodes(~K, l, d, nl), MI.nbs(~K, nl, n, id, p, forward, c)) : M.NodeStore<K> & Nat}:
  match c:
    case 0n:
      asl(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, 1n+n, forward, M.Ascend{id, p, False{}})
    case 1n+ +j:
      %Equal.sym(M.NodeStore<K> & Nat, M.extreme_at(~K, ~V, ~cmp, Bool.not(forward), ST.nodes(~K, l, d, nl), j), (ST.nodes(~K, l, d, nl), M.child(~K, ST.nth_or(M.Node<K>, nl, j, M.Free{0n}), Bool.not(forward))), ext_at(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, Bool.not(forward), j)) : {M.extreme_slots_loop(~K, ~V, ~cmp, 1n+n, Bool.not(forward), 1n+j, _) == (ST.nodes(~K, l, d, nl), MI.nbs(~K, nl, n, id, p, forward, 1n+j)) : M.NodeStore<K> & Nat}
      esl(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, 1n+n, Bool.not(forward), 1n+j, M.child(~K, ST.nth_or(M.Node<K>, nl, j, M.Free{0n}), Bool.not(forward)))

def neighbor_node_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +forward: Bool, r: ST.Sh<K, V> & M.Node<K>, +g_r: {MI.dgp(K, V, M.Node<K>, r) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.neighbor_node(~K, ~V, ~cmp, id, forward, r)) == True{} : Bool}:
  match r:
    case Tuple{ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl}, +node}:
      g_r

def neighbor_node_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +forward: Bool, r: ST.Sh<K, V> & M.Node<K>, +g_r: {MI.dgp(K, V, M.Node<K>, r) == True{} : Bool}) -> {M.neighbor_node(~K, ~V, ~cmp, id, forward, MI.rp(~K, ~V, ~cmp, M.Node<K>, r)) == MI.rp(~K, ~V, ~cmp, Nat, MI.neighbor_node(~K, ~V, ~cmp, id, forward, r)) : M.TreeMap<K, V, cmp> & Nat}:
  match r:
    case Tuple{ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl}, +node}:
      %Equal.sym(M.NodeStore<K> & Nat, M.neighbor_slots(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), n, id, M.node_parent(~K, node), forward, M.child(~K, node, forward)), (ST.nodes(~K, l, d, nl), MI.nbs(~K, nl, n, id, M.node_parent(~K, node), forward, M.child(~K, node, forward))), nbl(~K, ~V, ~cmp, l, d, nl, L.and_left(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_r), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_r)), L.and_left(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_r))), n, id, M.node_parent(~K, node), forward, M.child(~K, node, forward))) : {M.neighbor_slots_finish(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), _) == MI.rp(~K, ~V, ~cmp, Nat, MI.neighbor_node(~K, ~V, ~cmp, id, forward, Tuple{ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, node})) : M.TreeMap<K, V, cmp> & Nat}
      {==}

def size_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.size(~K, ~V, ~cmp, m)) == True{} : Bool}:
  match m:
    case ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}:
      g_m

def size_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.size(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)) == MI.rp(~K, ~V, ~cmp, Nat, MI.size(~K, ~V, ~cmp, m)) : M.TreeMap<K, V, cmp> & Nat}:
  match m:
    case ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}:
      {==}


def root_id_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.root_id(~K, ~V, ~cmp, m)) == True{} : Bool}:
  match m:
    case ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}:
      g_m

def root_id_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.root_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)) == MI.rp(~K, ~V, ~cmp, Nat, MI.root_id(~K, ~V, ~cmp, m)) : M.TreeMap<K, V, cmp> & Nat}:
  match m:
    case ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}:
      {==}


def first_id_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.first_id(~K, ~V, ~cmp, m)) == True{} : Bool}:
  match m:
    case ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}:
      g_m

def first_id_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.first_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)) == MI.rp(~K, ~V, ~cmp, Nat, MI.first_id(~K, ~V, ~cmp, m)) : M.TreeMap<K, V, cmp> & Nat}:
  match m:
    case ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}:
      {==}


def last_id_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.last_id(~K, ~V, ~cmp, m)) == True{} : Bool}:
  match m:
    case ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}:
      g_m

def last_id_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.last_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)) == MI.rp(~K, ~V, ~cmp, Nat, MI.last_id(~K, ~V, ~cmp, m)) : M.TreeMap<K, V, cmp> & Nat}:
  match m:
    case ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}:
      {==}


def set_root_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +root: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.set_root(~K, ~V, ~cmp, m, root)) == True{} : Bool}:
  match m:
    case ST.SH{+n, +old, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}:
      g_m

def set_root_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +root: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.set_root(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), root) == ST.real(~K, ~V, ~cmp, MI.set_root(~K, ~V, ~cmp, m, root)) : M.TreeMap<K, V, cmp>}:
  match m:
    case ST.SH{+n, +old, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}:
      {==}


def probe_node_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +k: K, r: ST.Sh<K, V> & M.Node<K>, +g_r: {MI.dgp(K, V, M.Node<K>, r) == True{} : Bool}) -> {MI.dgp(K, V, (M.Node<K> & Cmp), MI.probe_node(~K, ~V, ~cmp, id, k, r)) == True{} : Bool}:
  match r:
    case Tuple{+px2, M.Free{+px4}}:
      g_r
    case Tuple{+px2, M.N{+px5, +px6, +px7, +px8, +px9}}:
      g_r

def probe_node_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +k: K, r: ST.Sh<K, V> & M.Node<K>, +g_r: {MI.dgp(K, V, M.Node<K>, r) == True{} : Bool}) -> {M.probe_node(~K, ~V, ~cmp, id, k, MI.rp(~K, ~V, ~cmp, M.Node<K>, r)) == MI.rp(~K, ~V, ~cmp, (M.Node<K> & Cmp), MI.probe_node(~K, ~V, ~cmp, id, k, r)) : M.TreeMap<K, V, cmp> & (M.Node<K> & Cmp)}:
  match r:
    case Tuple{+px2, M.Free{+px4}}:
      {==}
    case Tuple{+px2, M.N{+px5, +px6, +px7, +px8, +px9}}:
      {==}


def free_header_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +free: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.free_header(~K, ~V, ~cmp, m, free)) == True{} : Bool}:
  match m:
    case ST.SH{+n, +root, +lo, +hi, +old, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}:
      g_m

def free_header_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +free: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.free_header(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), free) == ST.real(~K, ~V, ~cmp, MI.free_header(~K, ~V, ~cmp, m, free)) : M.TreeMap<K, V, cmp>}:
  match m:
    case ST.SH{+n, +root, +lo, +hi, +old, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}:
      {==}


def reuse_slot_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, pair_result: ST.Sh<K, V> & Maybe<&2, V>, +g_pair_result: {MI.dgp(K, V, Maybe<&2, V>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, Result<&2, &2, M.Rejected<K, V>, Nat>, MI.reuse_slot_1(~K, ~V, ~cmp, id, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m1, +old}:
      g_pair_result

def reuse_slot_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, pair_result: ST.Sh<K, V> & Maybe<&2, V>, +g_pair_result: {MI.dgp(K, V, Maybe<&2, V>, pair_result) == True{} : Bool}) -> {M.reuse_slot_1(~K, ~V, ~cmp, id, MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, pair_result)) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Nat>, MI.reuse_slot_1(~K, ~V, ~cmp, id, pair_result)) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Nat>}:
  match pair_result:
    case Tuple{+m1, +old}:
      {==}


def put_replaced_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh<K, V> & Maybe<&2, V>, +g_r: {MI.dgp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {MI.dgp(K, V, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put_replaced(~K, ~V, ~cmp, r)) == True{} : Bool}:
  match r:
    case Tuple{+m, +old}:
      g_r

def put_replaced_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh<K, V> & Maybe<&2, V>, +g_r: {MI.dgp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {M.put_replaced(~K, ~V, ~cmp, MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, r)) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put_replaced(~K, ~V, ~cmp, r)) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>}:
  match r:
    case Tuple{+m, +old}:
      {==}


def contains_found_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh<K, V> & M.Search, +g_r: {MI.dgp(K, V, M.Search, r) == True{} : Bool}) -> {MI.dgp(K, V, Bool, MI.contains_found(~K, ~V, ~cmp, r)) == True{} : Bool}:
  match r:
    case Tuple{+m, M.Search{+id, +p, +left}}:
      g_r

def contains_found_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh<K, V> & M.Search, +g_r: {MI.dgp(K, V, M.Search, r) == True{} : Bool}) -> {M.contains_found(~K, ~V, ~cmp, MI.rp(~K, ~V, ~cmp, M.Search, r)) == MI.rp(~K, ~V, ~cmp, Bool, MI.contains_found(~K, ~V, ~cmp, r)) : M.TreeMap<K, V, cmp> & Bool}:
  match r:
    case Tuple{+m, M.Search{+id, +p, +left}}:
      {==}


def move_successor_3_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +source: Nat, pair_result: ST.Sh<K, V> & Maybe<&2, V>, +g_pair_result: {MI.dgp(K, V, Maybe<&2, V>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.move_successor_3(~K, ~V, ~cmp, source, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m3, +old}:
      g_pair_result

def move_successor_3_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +source: Nat, pair_result: ST.Sh<K, V> & Maybe<&2, V>, +g_pair_result: {MI.dgp(K, V, Maybe<&2, V>, pair_result) == True{} : Bool}) -> {M.move_successor_3(~K, ~V, ~cmp, source, MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, pair_result)) == MI.rp(~K, ~V, ~cmp, Nat, MI.move_successor_3(~K, ~V, ~cmp, source, pair_result)) : M.TreeMap<K, V, cmp> & Nat}:
  match pair_result:
    case Tuple{+m3, +old}:
      {==}


def release_header_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.release_header(~K, ~V, ~cmp, m, id)) == True{} : Bool}:
  match m:
    case ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}:
      g_m

def release_header_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.release_header(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id) == ST.real(~K, ~V, ~cmp, MI.release_header(~K, ~V, ~cmp, m, id)) : M.TreeMap<K, V, cmp>}:
  match m:
    case ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}:
      {==}


def set_ends_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +lo: Nat, +hi: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.set_ends(~K, ~V, ~cmp, m, lo, hi)) == True{} : Bool}:
  match m:
    case ST.SH{+n, +root, +oldlo, +oldhi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}:
      g_m

def set_ends_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +lo: Nat, +hi: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.set_ends(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), lo, hi) == ST.real(~K, ~V, ~cmp, MI.set_ends(~K, ~V, ~cmp, m, lo, hi)) : M.TreeMap<K, V, cmp>}:
  match m:
    case ST.SH{+n, +root, +oldlo, +oldhi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}:
      {==}


def is_empty_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, pair_result: ST.Sh<K, V> & Nat, +g_pair_result: {MI.dgp(K, V, Nat, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, Bool, MI.is_empty_1(~K, ~V, ~cmp, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m1, +n}:
      g_pair_result

def is_empty_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, pair_result: ST.Sh<K, V> & Nat, +g_pair_result: {MI.dgp(K, V, Nat, pair_result) == True{} : Bool}) -> {M.is_empty_1(~K, ~V, ~cmp, MI.rp(~K, ~V, ~cmp, Nat, pair_result)) == MI.rp(~K, ~V, ~cmp, Bool, MI.is_empty_1(~K, ~V, ~cmp, pair_result)) : M.TreeMap<K, V, cmp> & Bool}:
  match pair_result:
    case Tuple{+m1, +n}:
      {==}


def entry_value_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +k: Maybe<&2, K>, r: ST.Sh<K, V> & Maybe<&2, V>, +g_r: {MI.dgp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, M.Entry<K, V>>, MI.entry_value(~K, ~V, ~cmp, k, r)) == True{} : Bool}:
  match k r:
    case Some{+px3} Tuple{+px4, Some{+px6}}:
      g_r
    case None{} Tuple{+px7, None{}}:
      g_r
    case None{} Tuple{+px7, Some{+px9}}:
      g_r
    case Some{+px3} Tuple{+px4, None{}}:
      g_r

def entry_value_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +k: Maybe<&2, K>, r: ST.Sh<K, V> & Maybe<&2, V>, +g_r: {MI.dgp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {M.entry_value(~K, ~V, ~cmp, k, MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, r)) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.entry_value(~K, ~V, ~cmp, k, r)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
  match k r:
    case Some{+px3} Tuple{+px4, Some{+px6}}:
      {==}
    case None{} Tuple{+px7, None{}}:
      {==}
    case None{} Tuple{+px7, Some{+px9}}:
      {==}
    case Some{+px3} Tuple{+px4, None{}}:
      {==}


def default_value_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +fallback: V, r: ST.Sh<K, V> & Maybe<&2, V>, +g_r: {MI.dgp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {MI.dgp(K, V, V, MI.default_value(~K, ~V, ~cmp, fallback, r)) == True{} : Bool}:
  match r:
    case Tuple{+px2, None{}}:
      g_r
    case Tuple{+px2, Some{+px4}}:
      g_r

def default_value_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +fallback: V, r: ST.Sh<K, V> & Maybe<&2, V>, +g_r: {MI.dgp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {M.default_value(~K, ~V, ~cmp, fallback, MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, r)) == MI.rp(~K, ~V, ~cmp, V, MI.default_value(~K, ~V, ~cmp, fallback, r)) : M.TreeMap<K, V, cmp> & V}:
  match r:
    case Tuple{+px2, None{}}:
      {==}
    case Tuple{+px2, Some{+px4}}:
      {==}


def view_checked_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +lower: M.Bound<K>, +upper: M.Bound<K>, +descending: Bool, +valid: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgr(K, V, MI.view_checked(~K, ~V, ~cmp, m, lower, upper, descending, valid)) == True{} : Bool}:
  match valid:
    case True{}:
      g_m
    case False{}:
      g_m

def view_checked_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +lower: M.Bound<K>, +upper: M.Bound<K>, +descending: Bool, +valid: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.view_checked(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), lower, upper, descending, valid) == MI.rr(~K, ~V, ~cmp, MI.view_checked(~K, ~V, ~cmp, m, lower, upper, descending, valid)) : Result<&1, &1, M.InvalidView<K, V, cmp>, M.View<K, V, cmp>>}:
  match valid:
    case True{}:
      {==}
    case False{}:
      {==}


def head_map_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +upper: M.Bound<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgv(K, V, MI.head_map(~K, ~V, ~cmp, m, upper)) == True{} : Bool}:
  g_m

def head_map_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +upper: M.Bound<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.head_map(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), upper) == MI.rv(~K, ~V, ~cmp, MI.head_map(~K, ~V, ~cmp, m, upper)) : M.View<K, V, cmp>}:
  {==}


def tail_map_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +lower: M.Bound<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgv(K, V, MI.tail_map(~K, ~V, ~cmp, m, lower)) == True{} : Bool}:
  g_m

def tail_map_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +lower: M.Bound<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.tail_map(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), lower) == MI.rv(~K, ~V, ~cmp, MI.tail_map(~K, ~V, ~cmp, m, lower)) : M.View<K, V, cmp>}:
  {==}


def descending_map_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgv(K, V, MI.descending_map(~K, ~V, ~cmp, m)) == True{} : Bool}:
  g_m

def descending_map_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.descending_map(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)) == MI.rv(~K, ~V, ~cmp, MI.descending_map(~K, ~V, ~cmp, m)) : M.View<K, V, cmp>}:
  {==}


def view_reverse_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {MI.dgv(K, V, MI.view_reverse(~K, ~V, ~cmp, view)) == True{} : Bool}:
  match view:
    case MI.MV{+m, +lower, +upper, +descending}:
      g_view

def view_reverse_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {M.view_reverse(~K, ~V, ~cmp, MI.rv(~K, ~V, ~cmp, view)) == MI.rv(~K, ~V, ~cmp, MI.view_reverse(~K, ~V, ~cmp, view)) : M.View<K, V, cmp>}:
  match view:
    case MI.MV{+m, +lower, +upper, +descending}:
      {==}


def view_finish_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {MI.dg(K, V, MI.view_finish(~K, ~V, ~cmp, view)) == True{} : Bool}:
  match view:
    case MI.MV{+m, +lower, +upper, +descending}:
      g_view

def view_finish_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {M.view_finish(~K, ~V, ~cmp, MI.rv(~K, ~V, ~cmp, view)) == ST.real(~K, ~V, ~cmp, MI.view_finish(~K, ~V, ~cmp, view)) : M.TreeMap<K, V, cmp>}:
  match view:
    case MI.MV{+m, +lower, +upper, +descending}:
      {==}


def view_value_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +lower: M.Bound<K>, +upper: M.Bound<K>, +descending: Bool, r: ST.Sh<K, V> & Maybe<&2, V>, +g_r: {MI.dgp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {MI.dgvp(K, V, Maybe<&2, V>, MI.view_value(~K, ~V, ~cmp, lower, upper, descending, r)) == True{} : Bool}:
  match r:
    case Tuple{+m, +v}:
      g_r

def view_value_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +lower: M.Bound<K>, +upper: M.Bound<K>, +descending: Bool, r: ST.Sh<K, V> & Maybe<&2, V>, +g_r: {MI.dgp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {M.view_value(~K, ~V, ~cmp, lower, upper, descending, MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, r)) == MI.rvp(~K, ~V, ~cmp, Maybe<&2, V>, MI.view_value(~K, ~V, ~cmp, lower, upper, descending, r)) : M.View<K, V, cmp> & Maybe<&2, V>}:
  match r:
    case Tuple{+m, +v}:
      {==}


def view_put_finish_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +lower: M.Bound<K>, +upper: M.Bound<K>, +descending: Bool, r: ST.Sh<K, V> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, +g_r: {MI.dgp(K, V, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, r) == True{} : Bool}) -> {MI.dgvp(K, V, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.view_put_finish(~K, ~V, ~cmp, lower, upper, descending, r)) == True{} : Bool}:
  match r:
    case Tuple{+m, +status}:
      g_r

def view_put_finish_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +lower: M.Bound<K>, +upper: M.Bound<K>, +descending: Bool, r: ST.Sh<K, V> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, +g_r: {MI.dgp(K, V, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, r) == True{} : Bool}) -> {M.view_put_finish(~K, ~V, ~cmp, lower, upper, descending, MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, r)) == MI.rvp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.view_put_finish(~K, ~V, ~cmp, lower, upper, descending, r)) : M.View<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>}:
  match r:
    case Tuple{+m, +status}:
      {==}


def cursor_started_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +lower: M.Bound<K>, +upper: M.Bound<K>, +forward: Bool, r: ST.Sh<K, V> & Nat, +g_r: {MI.dgp(K, V, Nat, r) == True{} : Bool}) -> {MI.dgc(K, V, MI.cursor_started(~K, ~V, ~cmp, lower, upper, forward, r)) == True{} : Bool}:
  match r:
    case Tuple{+m, +id}:
      g_r

def cursor_started_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +lower: M.Bound<K>, +upper: M.Bound<K>, +forward: Bool, r: ST.Sh<K, V> & Nat, +g_r: {MI.dgp(K, V, Nat, r) == True{} : Bool}) -> {M.cursor_started(~K, ~V, ~cmp, lower, upper, forward, MI.rp(~K, ~V, ~cmp, Nat, r)) == MI.rc(~K, ~V, ~cmp, MI.cursor_started(~K, ~V, ~cmp, lower, upper, forward, r)) : M.Cursor<K, V, cmp>}:
  match r:
    case Tuple{+m, +id}:
      {==}


def iterator_finish_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +cursor: MI.MCursor<K, V>, +g_cursor: {MI.dgc(K, V, cursor) == True{} : Bool}) -> {MI.dg(K, V, MI.iterator_finish(~K, ~V, ~cmp, cursor)) == True{} : Bool}:
  match cursor:
    case MI.MC{+m, +next, +current, +lower, +upper, +forward}:
      g_cursor

def iterator_finish_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +cursor: MI.MCursor<K, V>, +g_cursor: {MI.dgc(K, V, cursor) == True{} : Bool}) -> {M.iterator_finish(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, cursor)) == ST.real(~K, ~V, ~cmp, MI.iterator_finish(~K, ~V, ~cmp, cursor)) : M.TreeMap<K, V, cmp>}:
  match cursor:
    case MI.MC{+m, +next, +current, +lower, +upper, +forward}:
      {==}


def iterator_view_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +cursor: MI.MCursor<K, V>, +g_cursor: {MI.dgc(K, V, cursor) == True{} : Bool}) -> {MI.dgv(K, V, MI.iterator_view(~K, ~V, ~cmp, cursor)) == True{} : Bool}:
  match cursor:
    case MI.MC{+m, +next, +current, +lower, +upper, +forward}:
      g_cursor

def iterator_view_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +cursor: MI.MCursor<K, V>, +g_cursor: {MI.dgc(K, V, cursor) == True{} : Bool}) -> {M.iterator_view(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, cursor)) == MI.rv(~K, ~V, ~cmp, MI.iterator_view(~K, ~V, ~cmp, cursor)) : M.View<K, V, cmp>}:
  match cursor:
    case MI.MC{+m, +next, +current, +lower, +upper, +forward}:
      {==}


def iterator_yield_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +lower: M.Bound<K>, +upper: M.Bound<K>, +forward: Bool, +entry: M.Entry<K, V>, r: ST.Sh<K, V> & Nat, +g_r: {MI.dgp(K, V, Nat, r) == True{} : Bool}) -> {MI.dgcp(K, V, Maybe<&2, M.Entry<K, V>>, MI.iterator_yield(~K, ~V, ~cmp, id, lower, upper, forward, entry, r)) == True{} : Bool}:
  match r:
    case Tuple{+m, +next}:
      g_r

def iterator_yield_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +lower: M.Bound<K>, +upper: M.Bound<K>, +forward: Bool, +entry: M.Entry<K, V>, r: ST.Sh<K, V> & Nat, +g_r: {MI.dgp(K, V, Nat, r) == True{} : Bool}) -> {M.iterator_yield(~K, ~V, ~cmp, id, lower, upper, forward, entry, MI.rp(~K, ~V, ~cmp, Nat, r)) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.iterator_yield(~K, ~V, ~cmp, id, lower, upper, forward, entry, r)) : M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
  match r:
    case Tuple{+m, +next}:
      {==}


def iterator_set_done_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +next: Nat, +current: Nat, +lower: M.Bound<K>, +upper: M.Bound<K>, +forward: Bool, r: ST.Sh<K, V> & Maybe<&2, V>, +g_r: {MI.dgp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {MI.dgcp(K, V, Result<&2, &2, M.Error, V>, MI.iterator_set_done(~K, ~V, ~cmp, next, current, lower, upper, forward, r)) == True{} : Bool}:
  match r:
    case Tuple{+px2, Some{+px4}}:
      g_r
    case Tuple{+px2, None{}}:
      g_r

def iterator_set_done_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +next: Nat, +current: Nat, +lower: M.Bound<K>, +upper: M.Bound<K>, +forward: Bool, r: ST.Sh<K, V> & Maybe<&2, V>, +g_r: {MI.dgp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {M.iterator_set_done(~K, ~V, ~cmp, next, current, lower, upper, forward, MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, r)) == MI.rcp(~K, ~V, ~cmp, Result<&2, &2, M.Error, V>, MI.iterator_set_done(~K, ~V, ~cmp, next, current, lower, upper, forward, r)) : M.Cursor<K, V, cmp> & Result<&2, &2, M.Error, V>}:
  match r:
    case Tuple{+px2, Some{+px4}}:
      {==}
    case Tuple{+px2, None{}}:
      {==}


def iterator_relocated_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +lower: M.Bound<K>, +upper: M.Bound<K>, +forward: Bool, +removed: Maybe<&2, V>, r: ST.Sh<K, V> & M.Search, +g_r: {MI.dgp(K, V, M.Search, r) == True{} : Bool}) -> {MI.dgcp(K, V, Maybe<&2, V>, MI.iterator_relocated(~K, ~V, ~cmp, lower, upper, forward, removed, r)) == True{} : Bool}:
  match r:
    case Tuple{+m, M.Search{+id, +p, +on_left}}:
      g_r

def iterator_relocated_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +lower: M.Bound<K>, +upper: M.Bound<K>, +forward: Bool, +removed: Maybe<&2, V>, r: ST.Sh<K, V> & M.Search, +g_r: {MI.dgp(K, V, M.Search, r) == True{} : Bool}) -> {M.iterator_relocated(~K, ~V, ~cmp, lower, upper, forward, removed, MI.rp(~K, ~V, ~cmp, M.Search, r)) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, V>, MI.iterator_relocated(~K, ~V, ~cmp, lower, upper, forward, removed, r)) : M.Cursor<K, V, cmp> & Maybe<&2, V>}:
  match r:
    case Tuple{+m, M.Search{+id, +p, +on_left}}:
      {==}


def iterator_key_result_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: MI.MCursor<K, V> & Maybe<&2, M.Entry<K, V>>, +g_r: {MI.dgcp(K, V, Maybe<&2, M.Entry<K, V>>, r) == True{} : Bool}) -> {MI.dgcp(K, V, Maybe<&2, K>, MI.iterator_key_result(~K, ~V, ~cmp, r)) == True{} : Bool}:
  match r:
    case Tuple{+px2, None{}}:
      g_r
    case Tuple{+px2, Some{M.Entry{+px5, +px6}}}:
      g_r

def iterator_key_result_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: MI.MCursor<K, V> & Maybe<&2, M.Entry<K, V>>, +g_r: {MI.dgcp(K, V, Maybe<&2, M.Entry<K, V>>, r) == True{} : Bool}) -> {M.iterator_key_result(~K, ~V, ~cmp, MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, r)) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, K>, MI.iterator_key_result(~K, ~V, ~cmp, r)) : M.Cursor<K, V, cmp> & Maybe<&2, K>}:
  match r:
    case Tuple{+px2, None{}}:
      {==}
    case Tuple{+px2, Some{M.Entry{+px5, +px6}}}:
      {==}


def iterator_value_result_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: MI.MCursor<K, V> & Maybe<&2, M.Entry<K, V>>, +g_r: {MI.dgcp(K, V, Maybe<&2, M.Entry<K, V>>, r) == True{} : Bool}) -> {MI.dgcp(K, V, Maybe<&2, V>, MI.iterator_value_result(~K, ~V, ~cmp, r)) == True{} : Bool}:
  match r:
    case Tuple{+px2, None{}}:
      g_r
    case Tuple{+px2, Some{M.Entry{+px5, +px6}}}:
      g_r

def iterator_value_result_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: MI.MCursor<K, V> & Maybe<&2, M.Entry<K, V>>, +g_r: {MI.dgcp(K, V, Maybe<&2, M.Entry<K, V>>, r) == True{} : Bool}) -> {M.iterator_value_result(~K, ~V, ~cmp, MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, r)) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, V>, MI.iterator_value_result(~K, ~V, ~cmp, r)) : M.Cursor<K, V, cmp> & Maybe<&2, V>}:
  match r:
    case Tuple{+px2, None{}}:
      {==}
    case Tuple{+px2, Some{M.Entry{+px5, +px6}}}:
      {==}


def changed_value_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh<K, V> & Maybe<&2, V>, +g_r: {MI.dgp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {MI.dgp(K, V, Bool, MI.changed_value(~K, ~V, ~cmp, r)) == True{} : Bool}:
  match r:
    case Tuple{+px2, None{}}:
      g_r
    case Tuple{+px2, Some{+px4}}:
      g_r

def changed_value_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh<K, V> & Maybe<&2, V>, +g_r: {MI.dgp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {M.changed_value(~K, ~V, ~cmp, MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, r)) == MI.rp(~K, ~V, ~cmp, Bool, MI.changed_value(~K, ~V, ~cmp, r)) : M.TreeMap<K, V, cmp> & Bool}:
  match r:
    case Tuple{+px2, None{}}:
      {==}
    case Tuple{+px2, Some{+px4}}:
      {==}


def view_contains_value_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: MI.MView<K, V> & Maybe<&2, V>, +g_r: {MI.dgvp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {MI.dgvp(K, V, Bool, MI.view_contains_value(~K, ~V, ~cmp, r)) == True{} : Bool}:
  match r:
    case Tuple{+px2, None{}}:
      g_r
    case Tuple{+px2, Some{+px4}}:
      g_r

def view_contains_value_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: MI.MView<K, V> & Maybe<&2, V>, +g_r: {MI.dgvp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {M.view_contains_value(~K, ~V, ~cmp, MI.rvp(~K, ~V, ~cmp, Maybe<&2, V>, r)) == MI.rvp(~K, ~V, ~cmp, Bool, MI.view_contains_value(~K, ~V, ~cmp, r)) : M.View<K, V, cmp> & Bool}:
  match r:
    case Tuple{+px2, None{}}:
      {==}
    case Tuple{+px2, Some{+px4}}:
      {==}


def view_entry_checked_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +lower: M.Bound<K>, +upper: M.Bound<K>, +descending: Bool, +entry: M.Entry<K, V>, +valid: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgvp(K, V, Maybe<&2, M.Entry<K, V>>, MI.view_entry_checked(~K, ~V, ~cmp, m, lower, upper, descending, entry, valid)) == True{} : Bool}:
  match valid:
    case True{}:
      g_m
    case False{}:
      g_m

def view_entry_checked_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +lower: M.Bound<K>, +upper: M.Bound<K>, +descending: Bool, +entry: M.Entry<K, V>, +valid: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.view_entry_checked(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), lower, upper, descending, entry, valid) == MI.rvp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.view_entry_checked(~K, ~V, ~cmp, m, lower, upper, descending, entry, valid)) : M.View<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
  match valid:
    case True{}:
      {==}
    case False{}:
      {==}


def insert_header_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +p: Nat, +on_left: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.insert_header(~K, ~V, ~cmp, m, id, p, on_left)) == True{} : Bool}:
  match m:
    case ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}:
      g_m

def insert_header_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +p: Nat, +on_left: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.insert_header(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id, p, on_left) == ST.real(~K, ~V, ~cmp, MI.insert_header(~K, ~V, ~cmp, m, id, p, on_left)) : M.TreeMap<K, V, cmp>}:
  match m:
    case ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}:
      {==}


def ascend_step_node_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, +p: Nat, +forward: Bool, r: ST.Sh<K, V> & M.Node<K>, +g_r: {MI.dgp(K, V, M.Node<K>, r) == True{} : Bool}) -> {MI.dgp(K, V, M.Ascend, MI.ascend_step_node(~K, ~V, ~cmp, x, p, forward, r)) == True{} : Bool}:
  match r:
    case Tuple{+px2, M.Free{+px4}}:
      g_r
    case Tuple{+px2, M.N{+px5, +px6, +px7, +px8, +px9}}:
      g_r

def ascend_step_node_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, +p: Nat, +forward: Bool, r: ST.Sh<K, V> & M.Node<K>, +g_r: {MI.dgp(K, V, M.Node<K>, r) == True{} : Bool}) -> {M.ascend_step_node(~K, ~V, ~cmp, x, p, forward, MI.rp(~K, ~V, ~cmp, M.Node<K>, r)) == MI.rp(~K, ~V, ~cmp, M.Ascend, MI.ascend_step_node(~K, ~V, ~cmp, x, p, forward, r)) : M.TreeMap<K, V, cmp> & M.Ascend}:
  match r:
    case Tuple{+px2, M.Free{+px4}}:
      {==}
    case Tuple{+px2, M.N{+px5, +px6, +px7, +px8, +px9}}:
      {==}


def refresh_ends_3_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +lo: Nat, pair_result: ST.Sh<K, V> & Nat, +g_pair_result: {MI.dgp(K, V, Nat, pair_result) == True{} : Bool}) -> {MI.dg(K, V, MI.refresh_ends_3(~K, ~V, ~cmp, lo, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m3, +hi}:
      set_ends_g(~K, ~V, ~cmp, m3, lo, hi, g_pair_result)

def refresh_ends_3_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +lo: Nat, pair_result: ST.Sh<K, V> & Nat, +g_pair_result: {MI.dgp(K, V, Nat, pair_result) == True{} : Bool}) -> {M.refresh_ends_3(~K, ~V, ~cmp, lo, MI.rp(~K, ~V, ~cmp, Nat, pair_result)) == ST.real(~K, ~V, ~cmp, MI.refresh_ends_3(~K, ~V, ~cmp, lo, pair_result)) : M.TreeMap<K, V, cmp>}:
  match pair_result:
    case Tuple{+m3, +hi}:
      set_ends_s(~K, ~V, ~cmp, m3, lo, hi, g_pair_result)


def is_empty_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Bool, MI.is_empty(~K, ~V, ~cmp, m)) == True{} : Bool}:
  is_empty_1_g(~K, ~V, ~cmp, MI.size(~K, ~V, ~cmp, m), size_g(~K, ~V, ~cmp, m, g_m))

def is_empty_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.is_empty(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)) == MI.rp(~K, ~V, ~cmp, Bool, MI.is_empty(~K, ~V, ~cmp, m)) : M.TreeMap<K, V, cmp> & Bool}:
  %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.size(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)), MI.rp(~K, ~V, ~cmp, Nat, MI.size(~K, ~V, ~cmp, m)), size_s(~K, ~V, ~cmp, m, g_m)) : {M.is_empty_1(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Bool, MI.is_empty(~K, ~V, ~cmp, m)) : M.TreeMap<K, V, cmp> & Bool}
  is_empty_1_s(~K, ~V, ~cmp, MI.size(~K, ~V, ~cmp, m), size_g(~K, ~V, ~cmp, m, g_m))


def key_finish_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh<K, V> & M.Node<K>, +g_r: {MI.dgp(K, V, M.Node<K>, r) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, K>, MI.key_finish(~K, ~V, ~cmp, r)) == True{} : Bool}:
  match r:
    case Tuple{+m, +node}:
      g_r

def key_finish_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh<K, V> & M.Node<K>, +g_r: {MI.dgp(K, V, M.Node<K>, r) == True{} : Bool}) -> {M.key_finish(~K, ~V, ~cmp, MI.rp(~K, ~V, ~cmp, M.Node<K>, r)) == MI.rp(~K, ~V, ~cmp, Maybe<&2, K>, MI.key_finish(~K, ~V, ~cmp, r)) : M.TreeMap<K, V, cmp> & Maybe<&2, K>}:
  match r:
    case Tuple{+m, +node}:
      {==}


def range_unbounded_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +forward: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.range_unbounded(~K, ~V, ~cmp, m, forward)) == True{} : Bool}:
  match forward:
    case True{}:
      first_id_g(~K, ~V, ~cmp, m, g_m)
    case False{}:
      last_id_g(~K, ~V, ~cmp, m, g_m)

def range_unbounded_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +forward: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.range_unbounded(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), forward) == MI.rp(~K, ~V, ~cmp, Nat, MI.range_unbounded(~K, ~V, ~cmp, m, forward)) : M.TreeMap<K, V, cmp> & Nat}:
  match forward:
    case True{}:
      first_id_s(~K, ~V, ~cmp, m, g_m)
    case False{}:
      last_id_s(~K, ~V, ~cmp, m, g_m)


def iterator_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgc(K, V, MI.iterator(~K, ~V, ~cmp, m)) == True{} : Bool}:
  cursor_started_g(~K, ~V, ~cmp, M.Unbounded{}, M.Unbounded{}, True{}, MI.first_id(~K, ~V, ~cmp, m), first_id_g(~K, ~V, ~cmp, m, g_m))

def iterator_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.iterator(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)) == MI.rc(~K, ~V, ~cmp, MI.iterator(~K, ~V, ~cmp, m)) : M.Cursor<K, V, cmp>}:
  %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.first_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)), MI.rp(~K, ~V, ~cmp, Nat, MI.first_id(~K, ~V, ~cmp, m)), first_id_s(~K, ~V, ~cmp, m, g_m)) : {M.cursor_started(~K, ~V, ~cmp, M.Unbounded{}, M.Unbounded{}, True{}, _) == MI.rc(~K, ~V, ~cmp, MI.iterator(~K, ~V, ~cmp, m)) : M.Cursor<K, V, cmp>}
  cursor_started_s(~K, ~V, ~cmp, M.Unbounded{}, M.Unbounded{}, True{}, MI.first_id(~K, ~V, ~cmp, m), first_id_g(~K, ~V, ~cmp, m, g_m))


def descending_iterator_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgc(K, V, MI.descending_iterator(~K, ~V, ~cmp, m)) == True{} : Bool}:
  cursor_started_g(~K, ~V, ~cmp, M.Unbounded{}, M.Unbounded{}, False{}, MI.last_id(~K, ~V, ~cmp, m), last_id_g(~K, ~V, ~cmp, m, g_m))

def descending_iterator_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.descending_iterator(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)) == MI.rc(~K, ~V, ~cmp, MI.descending_iterator(~K, ~V, ~cmp, m)) : M.Cursor<K, V, cmp>}:
  %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.last_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)), MI.rp(~K, ~V, ~cmp, Nat, MI.last_id(~K, ~V, ~cmp, m)), last_id_s(~K, ~V, ~cmp, m, g_m)) : {M.cursor_started(~K, ~V, ~cmp, M.Unbounded{}, M.Unbounded{}, False{}, _) == MI.rc(~K, ~V, ~cmp, MI.descending_iterator(~K, ~V, ~cmp, m)) : M.Cursor<K, V, cmp>}
  cursor_started_s(~K, ~V, ~cmp, M.Unbounded{}, M.Unbounded{}, False{}, MI.last_id(~K, ~V, ~cmp, m), last_id_g(~K, ~V, ~cmp, m, g_m))


def get_found_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh<K, V> & M.Search, +g_r: {MI.dgp(K, V, M.Search, r) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, V>, MI.get_found(~K, ~V, ~cmp, r)) == True{} : Bool}:
  match r:
    case Tuple{+m, M.Search{+id, +p, +on_left}}:
      get_id_g(~K, ~V, ~cmp, m, id, g_r)

def get_found_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh<K, V> & M.Search, +g_r: {MI.dgp(K, V, M.Search, r) == True{} : Bool}) -> {M.get_found(~K, ~V, ~cmp, MI.rp(~K, ~V, ~cmp, M.Search, r)) == MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.get_found(~K, ~V, ~cmp, r)) : M.TreeMap<K, V, cmp> & Maybe<&2, V>}:
  match r:
    case Tuple{+m, M.Search{+id, +p, +on_left}}:
      get_id_s(~K, ~V, ~cmp, m, id, g_r)


def replace_found_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +v: V, r: ST.Sh<K, V> & M.Search, +g_r: {MI.dgp(K, V, M.Search, r) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, V>, MI.replace_found(~K, ~V, ~cmp, v, r)) == True{} : Bool}:
  match r:
    case Tuple{+px2, M.Search{0n, +px5, +px6}}:
      g_r
    case Tuple{+px2, M.Search{1n+ +px7, +px5, +px6}}:
      exchange_g(~K, ~V, ~cmp, px2, 1n+px7, Some{v}, g_r)

def replace_found_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +v: V, r: ST.Sh<K, V> & M.Search, +g_r: {MI.dgp(K, V, M.Search, r) == True{} : Bool}) -> {M.replace_found(~K, ~V, ~cmp, v, MI.rp(~K, ~V, ~cmp, M.Search, r)) == MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.replace_found(~K, ~V, ~cmp, v, r)) : M.TreeMap<K, V, cmp> & Maybe<&2, V>}:
  match r:
    case Tuple{+px2, M.Search{0n, +px5, +px6}}:
      {==}
    case Tuple{+px2, M.Search{1n+ +px7, +px5, +px6}}:
      exchange_s(~K, ~V, ~cmp, px2, 1n+px7, Some{v}, g_r)


def sub_map_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +lower: M.Bound<K>, +upper: M.Bound<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgr(K, V, MI.sub_map(~K, ~V, ~cmp, m, lower, upper)) == True{} : Bool}:
  view_checked_g(~K, ~V, ~cmp, m, lower, upper, False{}, M.bounds_valid(~K, ~V, ~cmp, lower, upper), g_m)

def sub_map_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +lower: M.Bound<K>, +upper: M.Bound<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.sub_map(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), lower, upper) == MI.rr(~K, ~V, ~cmp, MI.sub_map(~K, ~V, ~cmp, m, lower, upper)) : Result<&1, &1, M.InvalidView<K, V, cmp>, M.View<K, V, cmp>>}:
  view_checked_s(~K, ~V, ~cmp, m, lower, upper, False{}, M.bounds_valid(~K, ~V, ~cmp, lower, upper), g_m)


def iterator_set_value_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +cursor: MI.MCursor<K, V>, +v: V, +g_cursor: {MI.dgc(K, V, cursor) == True{} : Bool}) -> {MI.dgcp(K, V, Result<&2, &2, M.Error, V>, MI.iterator_set_value(~K, ~V, ~cmp, cursor, v)) == True{} : Bool}:
  match cursor:
    case MI.MC{+px2, +px3, 0n, +px5, +px6, +px7}:
      g_cursor
    case MI.MC{+px2, +px3, 1n+ +px8, +px5, +px6, +px7}:
      iterator_set_done_g(~K, ~V, ~cmp, px3, 1n+px8, px5, px6, px7, MI.exchange(~K, ~V, ~cmp, px2, 1n+px8, Some{v}), exchange_g(~K, ~V, ~cmp, px2, 1n+px8, Some{v}, g_cursor))

def iterator_set_value_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +cursor: MI.MCursor<K, V>, +v: V, +g_cursor: {MI.dgc(K, V, cursor) == True{} : Bool}) -> {M.iterator_set_value(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, cursor), v) == MI.rcp(~K, ~V, ~cmp, Result<&2, &2, M.Error, V>, MI.iterator_set_value(~K, ~V, ~cmp, cursor, v)) : M.Cursor<K, V, cmp> & Result<&2, &2, M.Error, V>}:
  match cursor:
    case MI.MC{+px2, +px3, 0n, +px5, +px6, +px7}:
      {==}
    case MI.MC{+px2, +px3, 1n+ +px8, +px5, +px6, +px7}:
      %Equal.sym(M.TreeMap<K, V, cmp> & Maybe<&2, V>, M.exchange(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, px2), 1n+px8, Some{v}), MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.exchange(~K, ~V, ~cmp, px2, 1n+px8, Some{v})), exchange_s(~K, ~V, ~cmp, px2, 1n+px8, Some{v}, g_cursor)) : {M.iterator_set_done(~K, ~V, ~cmp, px3, 1n+px8, px5, px6, px7, _) == MI.rcp(~K, ~V, ~cmp, Result<&2, &2, M.Error, V>, MI.iterator_set_value(~K, ~V, ~cmp, MI.MC{px2, px3, 1n+ px8, px5, px6, px7}, v)) : M.Cursor<K, V, cmp> & Result<&2, &2, M.Error, V>}
      iterator_set_done_s(~K, ~V, ~cmp, px3, 1n+px8, px5, px6, px7, MI.exchange(~K, ~V, ~cmp, px2, 1n+px8, Some{v}), exchange_g(~K, ~V, ~cmp, px2, 1n+px8, Some{v}, g_cursor))


def entry_set_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgc(K, V, MI.entry_set(~K, ~V, ~cmp, m)) == True{} : Bool}:
  iterator_g(~K, ~V, ~cmp, m, g_m)

def entry_set_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.entry_set(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)) == MI.rc(~K, ~V, ~cmp, MI.entry_set(~K, ~V, ~cmp, m)) : M.Cursor<K, V, cmp>}:
  iterator_s(~K, ~V, ~cmp, m, g_m)


def key_set_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgc(K, V, MI.key_set(~K, ~V, ~cmp, m)) == True{} : Bool}:
  iterator_g(~K, ~V, ~cmp, m, g_m)

def key_set_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.key_set(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)) == MI.rc(~K, ~V, ~cmp, MI.key_set(~K, ~V, ~cmp, m)) : M.Cursor<K, V, cmp>}:
  iterator_s(~K, ~V, ~cmp, m, g_m)


def values_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgc(K, V, MI.values(~K, ~V, ~cmp, m)) == True{} : Bool}:
  iterator_g(~K, ~V, ~cmp, m, g_m)

def values_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.values(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)) == MI.rc(~K, ~V, ~cmp, MI.values(~K, ~V, ~cmp, m)) : M.Cursor<K, V, cmp>}:
  iterator_s(~K, ~V, ~cmp, m, g_m)


def replace_if_apply_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +replacement: V, +equal: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Bool, MI.replace_if_apply(~K, ~V, ~cmp, m, id, replacement, equal)) == True{} : Bool}:
  match equal:
    case False{}:
      g_m
    case True{}:
      changed_value_g(~K, ~V, ~cmp, MI.exchange(~K, ~V, ~cmp, m, id, Some{replacement}), exchange_g(~K, ~V, ~cmp, m, id, Some{replacement}, g_m))

def replace_if_apply_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +replacement: V, +equal: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.replace_if_apply(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id, replacement, equal) == MI.rp(~K, ~V, ~cmp, Bool, MI.replace_if_apply(~K, ~V, ~cmp, m, id, replacement, equal)) : M.TreeMap<K, V, cmp> & Bool}:
  match equal:
    case False{}:
      {==}
    case True{}:
      %Equal.sym(M.TreeMap<K, V, cmp> & Maybe<&2, V>, M.exchange(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id, Some{replacement}), MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.exchange(~K, ~V, ~cmp, m, id, Some{replacement})), exchange_s(~K, ~V, ~cmp, m, id, Some{replacement}, g_m)) : {M.changed_value(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Bool, MI.replace_if_apply(~K, ~V, ~cmp, m, id, replacement, True{})) : M.TreeMap<K, V, cmp> & Bool}
      changed_value_s(~K, ~V, ~cmp, MI.exchange(~K, ~V, ~cmp, m, id, Some{replacement}), exchange_g(~K, ~V, ~cmp, m, id, Some{replacement}, g_m))


def replace_if_value_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~eq: V -> V -> Bool, +id: Nat, +expected: V, +replacement: V, r: ST.Sh<K, V> & Maybe<&2, V>, +g_r: {MI.dgp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {MI.dgp(K, V, Bool, MI.replace_if_value(~K, ~V, ~cmp, ~eq, id, expected, replacement, r)) == True{} : Bool}:
  match r:
    case Tuple{+px2, None{}}:
      g_r
    case Tuple{+px2, Some{+px4}}:
      replace_if_apply_g(~K, ~V, ~cmp, px2, id, replacement, eq(px4, expected), g_r)

def replace_if_value_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~eq: V -> V -> Bool, +id: Nat, +expected: V, +replacement: V, r: ST.Sh<K, V> & Maybe<&2, V>, +g_r: {MI.dgp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {M.replace_if_value(~K, ~V, ~cmp, ~eq, id, expected, replacement, MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, r)) == MI.rp(~K, ~V, ~cmp, Bool, MI.replace_if_value(~K, ~V, ~cmp, ~eq, id, expected, replacement, r)) : M.TreeMap<K, V, cmp> & Bool}:
  match r:
    case Tuple{+px2, None{}}:
      {==}
    case Tuple{+px2, Some{+px4}}:
      replace_if_apply_s(~K, ~V, ~cmp, px2, id, replacement, eq(px4, expected), g_r)


def iterator_has_checked_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +next: Nat, +current: Nat, +lower: M.Bound<K>, +upper: M.Bound<K>, +forward: Bool, r: ST.Sh<K, V> & M.Node<K>, +g_r: {MI.dgp(K, V, M.Node<K>, r) == True{} : Bool}) -> {MI.dgcp(K, V, Bool, MI.iterator_has_checked(~K, ~V, ~cmp, next, current, lower, upper, forward, r)) == True{} : Bool}:
  match r:
    case Tuple{+px2, M.Free{+px4}}:
      g_r
    case Tuple{+px2, M.N{+px5, +px6, +px7, +px8, +px9}}:
      g_r

def iterator_has_checked_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +next: Nat, +current: Nat, +lower: M.Bound<K>, +upper: M.Bound<K>, +forward: Bool, r: ST.Sh<K, V> & M.Node<K>, +g_r: {MI.dgp(K, V, M.Node<K>, r) == True{} : Bool}) -> {M.iterator_has_checked(~K, ~V, ~cmp, next, current, lower, upper, forward, MI.rp(~K, ~V, ~cmp, M.Node<K>, r)) == MI.rcp(~K, ~V, ~cmp, Bool, MI.iterator_has_checked(~K, ~V, ~cmp, next, current, lower, upper, forward, r)) : M.Cursor<K, V, cmp> & Bool}:
  match r:
    case Tuple{+px2, M.Free{+px4}}:
      {==}
    case Tuple{+px2, M.N{+px5, +px6, +px7, +px8, +px9}}:
      {==}


def view_entry_result_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +lower: M.Bound<K>, +upper: M.Bound<K>, +descending: Bool, r: ST.Sh<K, V> & Maybe<&2, M.Entry<K, V>>, +g_r: {MI.dgp(K, V, Maybe<&2, M.Entry<K, V>>, r) == True{} : Bool}) -> {MI.dgvp(K, V, Maybe<&2, M.Entry<K, V>>, MI.view_entry_result(~K, ~V, ~cmp, lower, upper, descending, r)) == True{} : Bool}:
  match r:
    case Tuple{+px2, None{}}:
      g_r
    case Tuple{+px2, Some{M.Entry{+px5, +px6}}}:
      view_entry_checked_g(~K, ~V, ~cmp, px2, lower, upper, descending, M.Entry{px5, px6}, M.in_range(~K, ~V, ~cmp, px5, lower, upper), g_r)

def view_entry_result_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +lower: M.Bound<K>, +upper: M.Bound<K>, +descending: Bool, r: ST.Sh<K, V> & Maybe<&2, M.Entry<K, V>>, +g_r: {MI.dgp(K, V, Maybe<&2, M.Entry<K, V>>, r) == True{} : Bool}) -> {M.view_entry_result(~K, ~V, ~cmp, lower, upper, descending, MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, r)) == MI.rvp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.view_entry_result(~K, ~V, ~cmp, lower, upper, descending, r)) : M.View<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
  match r:
    case Tuple{+px2, None{}}:
      {==}
    case Tuple{+px2, Some{M.Entry{+px5, +px6}}}:
      view_entry_checked_s(~K, ~V, ~cmp, px2, lower, upper, descending, M.Entry{px5, px6}, M.in_range(~K, ~V, ~cmp, px5, lower, upper), g_r)


def attach_side_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +x: Nat, +on_left: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.attach_side(~K, ~V, ~cmp, m, p, x, on_left)) == True{} : Bool}:
  match p on_left:
    case 0n True{}:
      set_root_g(~K, ~V, ~cmp, m, x, g_m)
    case 0n False{}:
      set_root_g(~K, ~V, ~cmp, m, x, g_m)
    case 1n+ +px3 True{}:
      set_left_g(~K, ~V, ~cmp, m, 1n+px3, x, g_m)
    case 1n+ +px3 False{}:
      set_right_g(~K, ~V, ~cmp, m, 1n+px3, x, g_m)

def attach_side_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +x: Nat, +on_left: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.attach_side(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p, x, on_left) == ST.real(~K, ~V, ~cmp, MI.attach_side(~K, ~V, ~cmp, m, p, x, on_left)) : M.TreeMap<K, V, cmp>}:
  match p on_left:
    case 0n True{}:
      set_root_s(~K, ~V, ~cmp, m, x, g_m)
    case 0n False{}:
      set_root_s(~K, ~V, ~cmp, m, x, g_m)
    case 1n+ +px3 True{}:
      set_left_s(~K, ~V, ~cmp, m, 1n+px3, x, g_m)
    case 1n+ +px3 False{}:
      set_right_s(~K, ~V, ~cmp, m, 1n+px3, x, g_m)


def replace_if_found_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~eq: V -> V -> Bool, +expected: V, +replacement: V, r: ST.Sh<K, V> & M.Search, +g_r: {MI.dgp(K, V, M.Search, r) == True{} : Bool}) -> {MI.dgp(K, V, Bool, MI.replace_if_found(~K, ~V, ~cmp, ~eq, expected, replacement, r)) == True{} : Bool}:
  match r:
    case Tuple{+m, M.Search{+id, +p, +on_left}}:
      replace_if_value_g(~K, ~V, ~cmp, ~eq, id, expected, replacement, MI.get_id(~K, ~V, ~cmp, m, id), get_id_g(~K, ~V, ~cmp, m, id, g_r))

def replace_if_found_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~eq: V -> V -> Bool, +expected: V, +replacement: V, r: ST.Sh<K, V> & M.Search, +g_r: {MI.dgp(K, V, M.Search, r) == True{} : Bool}) -> {M.replace_if_found(~K, ~V, ~cmp, ~eq, expected, replacement, MI.rp(~K, ~V, ~cmp, M.Search, r)) == MI.rp(~K, ~V, ~cmp, Bool, MI.replace_if_found(~K, ~V, ~cmp, ~eq, expected, replacement, r)) : M.TreeMap<K, V, cmp> & Bool}:
  match r:
    case Tuple{+m, M.Search{+id, +p, +on_left}}:
      %Equal.sym(M.TreeMap<K, V, cmp> & Maybe<&2, V>, M.get_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id), MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.get_id(~K, ~V, ~cmp, m, id)), get_id_s(~K, ~V, ~cmp, m, id, g_r)) : {M.replace_if_value(~K, ~V, ~cmp, ~eq, id, expected, replacement, _) == MI.rp(~K, ~V, ~cmp, Bool, MI.replace_if_found(~K, ~V, ~cmp, ~eq, expected, replacement, Tuple{m, M.Search{id, p, on_left}})) : M.TreeMap<K, V, cmp> & Bool}
      replace_if_value_s(~K, ~V, ~cmp, ~eq, id, expected, replacement, MI.get_id(~K, ~V, ~cmp, m, id), get_id_g(~K, ~V, ~cmp, m, id, g_r))


def attach_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +x: Nat, +on_left: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.attach(~K, ~V, ~cmp, m, p, x, on_left)) == True{} : Bool}:
  set_parent_g(~K, ~V, ~cmp, MI.attach_side(~K, ~V, ~cmp, m, p, x, on_left), x, p, attach_side_g(~K, ~V, ~cmp, m, p, x, on_left, g_m))

def attach_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +x: Nat, +on_left: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.attach(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p, x, on_left) == ST.real(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, m, p, x, on_left)) : M.TreeMap<K, V, cmp>}:
  %Equal.sym(M.TreeMap<K, V, cmp>, M.attach_side(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p, x, on_left), ST.real(~K, ~V, ~cmp, MI.attach_side(~K, ~V, ~cmp, m, p, x, on_left)), attach_side_s(~K, ~V, ~cmp, m, p, x, on_left, g_m)) : {M.set_parent(~K, ~V, ~cmp, _, x, p) == ST.real(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, m, p, x, on_left)) : M.TreeMap<K, V, cmp>}
  set_parent_s(~K, ~V, ~cmp, MI.attach_side(~K, ~V, ~cmp, m, p, x, on_left), x, p, attach_side_g(~K, ~V, ~cmp, m, p, x, on_left, g_m))


def black_root_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, pair_result: ST.Sh<K, V> & Nat, +g_pair_result: {MI.dgp(K, V, Nat, pair_result) == True{} : Bool}) -> {MI.dg(K, V, MI.black_root_1(~K, ~V, ~cmp, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m1, +r}:
      set_red_g(~K, ~V, ~cmp, m1, r, False{}, g_pair_result)

def black_root_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, pair_result: ST.Sh<K, V> & Nat, +g_pair_result: {MI.dgp(K, V, Nat, pair_result) == True{} : Bool}) -> {M.black_root_1(~K, ~V, ~cmp, MI.rp(~K, ~V, ~cmp, Nat, pair_result)) == ST.real(~K, ~V, ~cmp, MI.black_root_1(~K, ~V, ~cmp, pair_result)) : M.TreeMap<K, V, cmp>}:
  match pair_result:
    case Tuple{+m1, +r}:
      set_red_s(~K, ~V, ~cmp, m1, r, False{}, g_pair_result)


def reuse_slot_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +next: Nat, +p: Nat, +k: K, +v: V, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Result<&2, &2, M.Rejected<K, V>, Nat>, MI.reuse_slot(~K, ~V, ~cmp, m, id, next, p, k, v)) == True{} : Bool}:
  reuse_slot_1_g(~K, ~V, ~cmp, id, MI.exchange(~K, ~V, ~cmp, MI.write(~K, ~V, ~cmp, MI.free_header(~K, ~V, ~cmp, m, next), id, M.N{True{}, 0n, 0n, p, k}), id, Some{v}), exchange_g(~K, ~V, ~cmp, MI.write(~K, ~V, ~cmp, MI.free_header(~K, ~V, ~cmp, m, next), id, M.N{True{}, 0n, 0n, p, k}), id, Some{v}, write_g(~K, ~V, ~cmp, MI.free_header(~K, ~V, ~cmp, m, next), id, M.N{True{}, 0n, 0n, p, k}, free_header_g(~K, ~V, ~cmp, m, next, g_m))))

def reuse_slot_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +next: Nat, +p: Nat, +k: K, +v: V, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.reuse_slot(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id, next, p, k, v) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Nat>, MI.reuse_slot(~K, ~V, ~cmp, m, id, next, p, k, v)) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Nat>}:
  %Equal.sym(M.TreeMap<K, V, cmp>, M.free_header(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), next), ST.real(~K, ~V, ~cmp, MI.free_header(~K, ~V, ~cmp, m, next)), free_header_s(~K, ~V, ~cmp, m, next, g_m)) : {M.reuse_slot_1(~K, ~V, ~cmp, id, M.exchange(~K, ~V, ~cmp, M.write(~K, ~V, ~cmp, _, id, M.N{True{}, 0n, 0n, p, k}), id, Some{v})) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Nat>, MI.reuse_slot(~K, ~V, ~cmp, m, id, next, p, k, v)) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Nat>}
  %Equal.sym(M.TreeMap<K, V, cmp>, M.write(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.free_header(~K, ~V, ~cmp, m, next)), id, M.N{True{}, 0n, 0n, p, k}), ST.real(~K, ~V, ~cmp, MI.write(~K, ~V, ~cmp, MI.free_header(~K, ~V, ~cmp, m, next), id, M.N{True{}, 0n, 0n, p, k})), write_s(~K, ~V, ~cmp, MI.free_header(~K, ~V, ~cmp, m, next), id, M.N{True{}, 0n, 0n, p, k}, free_header_g(~K, ~V, ~cmp, m, next, g_m))) : {M.reuse_slot_1(~K, ~V, ~cmp, id, M.exchange(~K, ~V, ~cmp, _, id, Some{v})) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Nat>, MI.reuse_slot(~K, ~V, ~cmp, m, id, next, p, k, v)) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Nat>}
  %Equal.sym(M.TreeMap<K, V, cmp> & Maybe<&2, V>, M.exchange(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.write(~K, ~V, ~cmp, MI.free_header(~K, ~V, ~cmp, m, next), id, M.N{True{}, 0n, 0n, p, k})), id, Some{v}), MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.exchange(~K, ~V, ~cmp, MI.write(~K, ~V, ~cmp, MI.free_header(~K, ~V, ~cmp, m, next), id, M.N{True{}, 0n, 0n, p, k}), id, Some{v})), exchange_s(~K, ~V, ~cmp, MI.write(~K, ~V, ~cmp, MI.free_header(~K, ~V, ~cmp, m, next), id, M.N{True{}, 0n, 0n, p, k}), id, Some{v}, write_g(~K, ~V, ~cmp, MI.free_header(~K, ~V, ~cmp, m, next), id, M.N{True{}, 0n, 0n, p, k}, free_header_g(~K, ~V, ~cmp, m, next, g_m)))) : {M.reuse_slot_1(~K, ~V, ~cmp, id, _) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Nat>, MI.reuse_slot(~K, ~V, ~cmp, m, id, next, p, k, v)) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Nat>}
  reuse_slot_1_s(~K, ~V, ~cmp, id, MI.exchange(~K, ~V, ~cmp, MI.write(~K, ~V, ~cmp, MI.free_header(~K, ~V, ~cmp, m, next), id, M.N{True{}, 0n, 0n, p, k}), id, Some{v}), exchange_g(~K, ~V, ~cmp, MI.write(~K, ~V, ~cmp, MI.free_header(~K, ~V, ~cmp, m, next), id, M.N{True{}, 0n, 0n, p, k}), id, Some{v}, write_g(~K, ~V, ~cmp, MI.free_header(~K, ~V, ~cmp, m, next), id, M.N{True{}, 0n, 0n, p, k}, free_header_g(~K, ~V, ~cmp, m, next, g_m))))


def set_key_node_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +k: K, +node: M.Node<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.set_key_node(~K, ~V, ~cmp, m, id, k, node)) == True{} : Bool}:
  match node:
    case M.Free{+px2}:
      g_m
    case M.N{+px3, +px4, +px5, +px6, +px7}:
      write_g(~K, ~V, ~cmp, m, id, M.N{px3, px4, px5, px6, k}, g_m)

def set_key_node_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +k: K, +node: M.Node<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.set_key_node(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id, k, node) == ST.real(~K, ~V, ~cmp, MI.set_key_node(~K, ~V, ~cmp, m, id, k, node)) : M.TreeMap<K, V, cmp>}:
  match node:
    case M.Free{+px2}:
      {==}
    case M.N{+px3, +px4, +px5, +px6, +px7}:
      write_s(~K, ~V, ~cmp, m, id, M.N{px3, px4, px5, px6, k}, g_m)


def recycle_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.recycle(~K, ~V, ~cmp, m, id)) == True{} : Bool}:
  match m:
    case ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}:
      release_header_g(~K, ~V, ~cmp, MI.write(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, id, M.Free{free}), id, write_g(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, id, M.Free{free}, g_m))

def recycle_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.recycle(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id) == ST.real(~K, ~V, ~cmp, MI.recycle(~K, ~V, ~cmp, m, id)) : M.TreeMap<K, V, cmp>}:
  match m:
    case ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}:
      %Equal.sym(M.TreeMap<K, V, cmp>, M.write(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}), id, M.Free{free}), ST.real(~K, ~V, ~cmp, MI.write(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, id, M.Free{free})), write_s(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, id, M.Free{free}, g_m)) : {M.release_header(~K, ~V, ~cmp, _, id) == ST.real(~K, ~V, ~cmp, MI.recycle(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, id)) : M.TreeMap<K, V, cmp>}
      release_header_s(~K, ~V, ~cmp, MI.write(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, id, M.Free{free}), id, write_g(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, id, M.Free{free}, g_m))


# ---- entry_snapshot: the key and the value, the mirror's whole node ----


def es_y(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +y: M.Node<K>, +w: Maybe<&2, V>) -> {M.snap_kv(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), ST.nodes(~K, l, d, nl), M.nkey(~K, y), w) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.entry_value(~K, ~V, ~cmp, M.node_key(~K, y), (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, w))) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
  match y w:
    case M.Free{z} None{}:
      {==}
    case M.Free{z} Some{x}:
      {==}
    case M.N{c, lf, rt, q, key} None{}:
      {==}
    case M.N{c, lf, rt, q, key} Some{v}:
      {==}

def es_n(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)) == True{} : Bool}, +id: Nat) -> {M.snap_at(~K, ~V, ~cmp, id, ST.real(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl})) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.entry_snapshot(~K, ~V, ~cmp, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, id))) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
  match id:
    case 0n:
      {==}
    case 1n+ +i:
      %Equal.sym(M.TreeMap<K, V, cmp> & Maybe<&2, V>, M.get_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}), 1n+i), (ST.real(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}), ST.pv(V, pl, 1n+i)), PR.get_id_c(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, hl, hd, hc, hp, 1n+i)) : {M.snap_value(~K, ~V, ~cmp, i, _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.entry_snapshot(~K, ~V, ~cmp, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, 1n+i))) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
      %Equal.sym(M.NodeStore<K> & Maybe<&2, K>, M.ns_key_at(~K, ST.nodes(~K, l, d, nl), i), (ST.nodes(~K, l, d, nl), M.nkey(~K, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}))), NSL.key_at_ok(~K, l, d, nl, hl, hd, hc, i)) : {M.snap_key(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), ST.nth_or(Maybe<&2, V>, pl, i, None{}), _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.entry_snapshot(~K, ~V, ~cmp, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, 1n+i))) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
      es_y(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}), ST.nth_or(Maybe<&2, V>, pl, i, None{}))

def es_m(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.snap_at(~K, ~V, ~cmp, id, ST.real(~K, ~V, ~cmp, m)) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.entry_snapshot(~K, ~V, ~cmp, (m, id))) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
  match m:
    case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl}:
      es_n(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, L.and_left(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), id)

def entry_snapshot_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh<K, V> & Nat, +g_r: {MI.dgp(K, V, Nat, r) == True{} : Bool}) -> {M.entry_snapshot(~K, ~V, ~cmp, MI.rp(~K, ~V, ~cmp, Nat, r)) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.entry_snapshot(~K, ~V, ~cmp, r)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
  match r:
    case Tuple{+m, +id}:
      es_m(~K, ~V, ~cmp, m, id, g_r)

def entry_snapshot_value_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, r: ST.Sh<K, V> & M.Node<K>, +g_r: {MI.dgp(K, V, M.Node<K>, r) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, M.Entry<K, V>>, MI.entry_snapshot_value(~K, ~V, ~cmp, id, r)) == True{} : Bool}:
  match r:
    case Tuple{+m, +node}:
      entry_value_g(~K, ~V, ~cmp, M.node_key(~K, node), MI.get_id(~K, ~V, ~cmp, m, id), get_id_g(~K, ~V, ~cmp, m, id, g_r))

def entry_snapshot_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh<K, V> & Nat, +g_r: {MI.dgp(K, V, Nat, r) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, M.Entry<K, V>>, MI.entry_snapshot(~K, ~V, ~cmp, r)) == True{} : Bool}:
  match r:
    case Tuple{+m, +id}:
      entry_snapshot_value_g(~K, ~V, ~cmp, id, MI.read(~K, ~V, ~cmp, m, id), read_g(~K, ~V, ~cmp, m, id, g_r))

def rotate_left_3_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, +xn: M.Node<K>, +yn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dg(K, V, MI.rotate_left_3(~K, ~V, ~cmp, x, xn, yn, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m3, +pn}:
      set_parent_g(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn)), M.node_left(~K, yn), x), M.node_parent(~K, xn), M.node_right(~K, xn), Nat.is_eq(M.node_left(~K, pn), x)), M.node_right(~K, xn), x), x, M.node_right(~K, xn), set_left_g(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn)), M.node_left(~K, yn), x), M.node_parent(~K, xn), M.node_right(~K, xn), Nat.is_eq(M.node_left(~K, pn), x)), M.node_right(~K, xn), x, attach_g(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn)), M.node_left(~K, yn), x), M.node_parent(~K, xn), M.node_right(~K, xn), Nat.is_eq(M.node_left(~K, pn), x), set_parent_g(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn)), M.node_left(~K, yn), x, set_right_g(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn), g_pair_result)))))

def rotate_left_3_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, +xn: M.Node<K>, +yn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.rotate_left_3(~K, ~V, ~cmp, x, xn, yn, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == ST.real(~K, ~V, ~cmp, MI.rotate_left_3(~K, ~V, ~cmp, x, xn, yn, pair_result)) : M.TreeMap<K, V, cmp>}:
  match pair_result:
    case Tuple{+m3, +pn}:
      %Equal.sym(M.TreeMap<K, V, cmp>, M.set_right(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m3), x, M.node_left(~K, yn)), ST.real(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn))), set_right_s(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn), g_pair_result)) : {M.set_parent(~K, ~V, ~cmp, M.set_left(~K, ~V, ~cmp, M.attach(~K, ~V, ~cmp, M.set_parent(~K, ~V, ~cmp, _, M.node_left(~K, yn), x), M.node_parent(~K, xn), M.node_right(~K, xn), Nat.is_eq(M.node_left(~K, pn), x)), M.node_right(~K, xn), x), x, M.node_right(~K, xn)) == ST.real(~K, ~V, ~cmp, MI.rotate_left_3(~K, ~V, ~cmp, x, xn, yn, Tuple{m3, pn})) : M.TreeMap<K, V, cmp>}
      %Equal.sym(M.TreeMap<K, V, cmp>, M.set_parent(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn))), M.node_left(~K, yn), x), ST.real(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn)), M.node_left(~K, yn), x)), set_parent_s(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn)), M.node_left(~K, yn), x, set_right_g(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn), g_pair_result))) : {M.set_parent(~K, ~V, ~cmp, M.set_left(~K, ~V, ~cmp, M.attach(~K, ~V, ~cmp, _, M.node_parent(~K, xn), M.node_right(~K, xn), Nat.is_eq(M.node_left(~K, pn), x)), M.node_right(~K, xn), x), x, M.node_right(~K, xn)) == ST.real(~K, ~V, ~cmp, MI.rotate_left_3(~K, ~V, ~cmp, x, xn, yn, Tuple{m3, pn})) : M.TreeMap<K, V, cmp>}
      %Equal.sym(M.TreeMap<K, V, cmp>, M.attach(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn)), M.node_left(~K, yn), x)), M.node_parent(~K, xn), M.node_right(~K, xn), Nat.is_eq(M.node_left(~K, pn), x)), ST.real(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn)), M.node_left(~K, yn), x), M.node_parent(~K, xn), M.node_right(~K, xn), Nat.is_eq(M.node_left(~K, pn), x))), attach_s(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn)), M.node_left(~K, yn), x), M.node_parent(~K, xn), M.node_right(~K, xn), Nat.is_eq(M.node_left(~K, pn), x), set_parent_g(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn)), M.node_left(~K, yn), x, set_right_g(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn), g_pair_result)))) : {M.set_parent(~K, ~V, ~cmp, M.set_left(~K, ~V, ~cmp, _, M.node_right(~K, xn), x), x, M.node_right(~K, xn)) == ST.real(~K, ~V, ~cmp, MI.rotate_left_3(~K, ~V, ~cmp, x, xn, yn, Tuple{m3, pn})) : M.TreeMap<K, V, cmp>}
      %Equal.sym(M.TreeMap<K, V, cmp>, M.set_left(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn)), M.node_left(~K, yn), x), M.node_parent(~K, xn), M.node_right(~K, xn), Nat.is_eq(M.node_left(~K, pn), x))), M.node_right(~K, xn), x), ST.real(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn)), M.node_left(~K, yn), x), M.node_parent(~K, xn), M.node_right(~K, xn), Nat.is_eq(M.node_left(~K, pn), x)), M.node_right(~K, xn), x)), set_left_s(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn)), M.node_left(~K, yn), x), M.node_parent(~K, xn), M.node_right(~K, xn), Nat.is_eq(M.node_left(~K, pn), x)), M.node_right(~K, xn), x, attach_g(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn)), M.node_left(~K, yn), x), M.node_parent(~K, xn), M.node_right(~K, xn), Nat.is_eq(M.node_left(~K, pn), x), set_parent_g(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn)), M.node_left(~K, yn), x, set_right_g(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn), g_pair_result))))) : {M.set_parent(~K, ~V, ~cmp, _, x, M.node_right(~K, xn)) == ST.real(~K, ~V, ~cmp, MI.rotate_left_3(~K, ~V, ~cmp, x, xn, yn, Tuple{m3, pn})) : M.TreeMap<K, V, cmp>}
      set_parent_s(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn)), M.node_left(~K, yn), x), M.node_parent(~K, xn), M.node_right(~K, xn), Nat.is_eq(M.node_left(~K, pn), x)), M.node_right(~K, xn), x), x, M.node_right(~K, xn), set_left_g(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn)), M.node_left(~K, yn), x), M.node_parent(~K, xn), M.node_right(~K, xn), Nat.is_eq(M.node_left(~K, pn), x)), M.node_right(~K, xn), x, attach_g(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn)), M.node_left(~K, yn), x), M.node_parent(~K, xn), M.node_right(~K, xn), Nat.is_eq(M.node_left(~K, pn), x), set_parent_g(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn)), M.node_left(~K, yn), x, set_right_g(~K, ~V, ~cmp, m3, x, M.node_left(~K, yn), g_pair_result)))))


def rotate_right_3_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, +xn: M.Node<K>, +yn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dg(K, V, MI.rotate_right_3(~K, ~V, ~cmp, x, xn, yn, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m3, +pn}:
      set_parent_g(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn)), M.node_right(~K, yn), x), M.node_parent(~K, xn), M.node_left(~K, xn), Nat.is_eq(M.node_left(~K, pn), x)), M.node_left(~K, xn), x), x, M.node_left(~K, xn), set_right_g(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn)), M.node_right(~K, yn), x), M.node_parent(~K, xn), M.node_left(~K, xn), Nat.is_eq(M.node_left(~K, pn), x)), M.node_left(~K, xn), x, attach_g(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn)), M.node_right(~K, yn), x), M.node_parent(~K, xn), M.node_left(~K, xn), Nat.is_eq(M.node_left(~K, pn), x), set_parent_g(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn)), M.node_right(~K, yn), x, set_left_g(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn), g_pair_result)))))

def rotate_right_3_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, +xn: M.Node<K>, +yn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.rotate_right_3(~K, ~V, ~cmp, x, xn, yn, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == ST.real(~K, ~V, ~cmp, MI.rotate_right_3(~K, ~V, ~cmp, x, xn, yn, pair_result)) : M.TreeMap<K, V, cmp>}:
  match pair_result:
    case Tuple{+m3, +pn}:
      %Equal.sym(M.TreeMap<K, V, cmp>, M.set_left(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m3), x, M.node_right(~K, yn)), ST.real(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn))), set_left_s(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn), g_pair_result)) : {M.set_parent(~K, ~V, ~cmp, M.set_right(~K, ~V, ~cmp, M.attach(~K, ~V, ~cmp, M.set_parent(~K, ~V, ~cmp, _, M.node_right(~K, yn), x), M.node_parent(~K, xn), M.node_left(~K, xn), Nat.is_eq(M.node_left(~K, pn), x)), M.node_left(~K, xn), x), x, M.node_left(~K, xn)) == ST.real(~K, ~V, ~cmp, MI.rotate_right_3(~K, ~V, ~cmp, x, xn, yn, Tuple{m3, pn})) : M.TreeMap<K, V, cmp>}
      %Equal.sym(M.TreeMap<K, V, cmp>, M.set_parent(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn))), M.node_right(~K, yn), x), ST.real(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn)), M.node_right(~K, yn), x)), set_parent_s(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn)), M.node_right(~K, yn), x, set_left_g(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn), g_pair_result))) : {M.set_parent(~K, ~V, ~cmp, M.set_right(~K, ~V, ~cmp, M.attach(~K, ~V, ~cmp, _, M.node_parent(~K, xn), M.node_left(~K, xn), Nat.is_eq(M.node_left(~K, pn), x)), M.node_left(~K, xn), x), x, M.node_left(~K, xn)) == ST.real(~K, ~V, ~cmp, MI.rotate_right_3(~K, ~V, ~cmp, x, xn, yn, Tuple{m3, pn})) : M.TreeMap<K, V, cmp>}
      %Equal.sym(M.TreeMap<K, V, cmp>, M.attach(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn)), M.node_right(~K, yn), x)), M.node_parent(~K, xn), M.node_left(~K, xn), Nat.is_eq(M.node_left(~K, pn), x)), ST.real(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn)), M.node_right(~K, yn), x), M.node_parent(~K, xn), M.node_left(~K, xn), Nat.is_eq(M.node_left(~K, pn), x))), attach_s(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn)), M.node_right(~K, yn), x), M.node_parent(~K, xn), M.node_left(~K, xn), Nat.is_eq(M.node_left(~K, pn), x), set_parent_g(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn)), M.node_right(~K, yn), x, set_left_g(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn), g_pair_result)))) : {M.set_parent(~K, ~V, ~cmp, M.set_right(~K, ~V, ~cmp, _, M.node_left(~K, xn), x), x, M.node_left(~K, xn)) == ST.real(~K, ~V, ~cmp, MI.rotate_right_3(~K, ~V, ~cmp, x, xn, yn, Tuple{m3, pn})) : M.TreeMap<K, V, cmp>}
      %Equal.sym(M.TreeMap<K, V, cmp>, M.set_right(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn)), M.node_right(~K, yn), x), M.node_parent(~K, xn), M.node_left(~K, xn), Nat.is_eq(M.node_left(~K, pn), x))), M.node_left(~K, xn), x), ST.real(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn)), M.node_right(~K, yn), x), M.node_parent(~K, xn), M.node_left(~K, xn), Nat.is_eq(M.node_left(~K, pn), x)), M.node_left(~K, xn), x)), set_right_s(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn)), M.node_right(~K, yn), x), M.node_parent(~K, xn), M.node_left(~K, xn), Nat.is_eq(M.node_left(~K, pn), x)), M.node_left(~K, xn), x, attach_g(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn)), M.node_right(~K, yn), x), M.node_parent(~K, xn), M.node_left(~K, xn), Nat.is_eq(M.node_left(~K, pn), x), set_parent_g(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn)), M.node_right(~K, yn), x, set_left_g(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn), g_pair_result))))) : {M.set_parent(~K, ~V, ~cmp, _, x, M.node_left(~K, xn)) == ST.real(~K, ~V, ~cmp, MI.rotate_right_3(~K, ~V, ~cmp, x, xn, yn, Tuple{m3, pn})) : M.TreeMap<K, V, cmp>}
      set_parent_s(~K, ~V, ~cmp, MI.set_right(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn)), M.node_right(~K, yn), x), M.node_parent(~K, xn), M.node_left(~K, xn), Nat.is_eq(M.node_left(~K, pn), x)), M.node_left(~K, xn), x), x, M.node_left(~K, xn), set_right_g(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn)), M.node_right(~K, yn), x), M.node_parent(~K, xn), M.node_left(~K, xn), Nat.is_eq(M.node_left(~K, pn), x)), M.node_left(~K, xn), x, attach_g(~K, ~V, ~cmp, MI.set_parent(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn)), M.node_right(~K, yn), x), M.node_parent(~K, xn), M.node_left(~K, xn), Nat.is_eq(M.node_left(~K, pn), x), set_parent_g(~K, ~V, ~cmp, MI.set_left(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn)), M.node_right(~K, yn), x, set_left_g(~K, ~V, ~cmp, m3, x, M.node_right(~K, yn), g_pair_result)))))


def black_root_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.black_root(~K, ~V, ~cmp, m)) == True{} : Bool}:
  black_root_1_g(~K, ~V, ~cmp, MI.root_id(~K, ~V, ~cmp, m), root_id_g(~K, ~V, ~cmp, m, g_m))

def black_root_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.black_root(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)) == ST.real(~K, ~V, ~cmp, MI.black_root(~K, ~V, ~cmp, m)) : M.TreeMap<K, V, cmp>}:
  %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.root_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)), MI.rp(~K, ~V, ~cmp, Nat, MI.root_id(~K, ~V, ~cmp, m)), root_id_s(~K, ~V, ~cmp, m, g_m)) : {M.black_root_1(~K, ~V, ~cmp, _) == ST.real(~K, ~V, ~cmp, MI.black_root(~K, ~V, ~cmp, m)) : M.TreeMap<K, V, cmp>}
  black_root_1_s(~K, ~V, ~cmp, MI.root_id(~K, ~V, ~cmp, m), root_id_g(~K, ~V, ~cmp, m, g_m))


def alloc_read_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +p: Nat, +k: K, +v: V, r: ST.Sh<K, V> & M.Node<K>, +g_r: {MI.dgp(K, V, M.Node<K>, r) == True{} : Bool}) -> {MI.dgp(K, V, Result<&2, &2, M.Rejected<K, V>, Nat>, MI.alloc_read(~K, ~V, ~cmp, id, p, k, v, r)) == True{} : Bool}:
  match r:
    case Tuple{+px2, M.Free{+px4}}:
      reuse_slot_g(~K, ~V, ~cmp, px2, id, px4, p, k, v, g_r)
    case Tuple{+px2, M.N{+px5, +px6, +px7, +px8, +px9}}:
      g_r

def alloc_read_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +p: Nat, +k: K, +v: V, r: ST.Sh<K, V> & M.Node<K>, +g_r: {MI.dgp(K, V, M.Node<K>, r) == True{} : Bool}) -> {M.alloc_read(~K, ~V, ~cmp, id, p, k, v, MI.rp(~K, ~V, ~cmp, M.Node<K>, r)) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Nat>, MI.alloc_read(~K, ~V, ~cmp, id, p, k, v, r)) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Nat>}:
  match r:
    case Tuple{+px2, M.Free{+px4}}:
      reuse_slot_s(~K, ~V, ~cmp, px2, id, px4, p, k, v, g_r)
    case Tuple{+px2, M.N{+px5, +px6, +px7, +px8, +px9}}:
      {==}


def set_key_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +k: K, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dg(K, V, MI.set_key_1(~K, ~V, ~cmp, id, k, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m1, +node}:
      set_key_node_g(~K, ~V, ~cmp, m1, id, k, node, g_pair_result)

def set_key_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +k: K, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.set_key_1(~K, ~V, ~cmp, id, k, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == ST.real(~K, ~V, ~cmp, MI.set_key_1(~K, ~V, ~cmp, id, k, pair_result)) : M.TreeMap<K, V, cmp>}:
  match pair_result:
    case Tuple{+m1, +node}:
      set_key_node_s(~K, ~V, ~cmp, m1, id, k, node, g_pair_result)


def first_entry_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, M.Entry<K, V>>, MI.first_entry(~K, ~V, ~cmp, m)) == True{} : Bool}:
  entry_snapshot_g(~K, ~V, ~cmp, MI.first_id(~K, ~V, ~cmp, m), first_id_g(~K, ~V, ~cmp, m, g_m))

def first_entry_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.first_entry(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.first_entry(~K, ~V, ~cmp, m)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
  %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.first_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)), MI.rp(~K, ~V, ~cmp, Nat, MI.first_id(~K, ~V, ~cmp, m)), first_id_s(~K, ~V, ~cmp, m, g_m)) : {M.entry_snapshot(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.first_entry(~K, ~V, ~cmp, m)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
  entry_snapshot_s(~K, ~V, ~cmp, MI.first_id(~K, ~V, ~cmp, m), first_id_g(~K, ~V, ~cmp, m, g_m))


def last_entry_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, M.Entry<K, V>>, MI.last_entry(~K, ~V, ~cmp, m)) == True{} : Bool}:
  entry_snapshot_g(~K, ~V, ~cmp, MI.last_id(~K, ~V, ~cmp, m), last_id_g(~K, ~V, ~cmp, m, g_m))

def last_entry_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.last_entry(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.last_entry(~K, ~V, ~cmp, m)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
  %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.last_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)), MI.rp(~K, ~V, ~cmp, Nat, MI.last_id(~K, ~V, ~cmp, m)), last_id_s(~K, ~V, ~cmp, m, g_m)) : {M.entry_snapshot(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.last_entry(~K, ~V, ~cmp, m)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
  entry_snapshot_s(~K, ~V, ~cmp, MI.last_id(~K, ~V, ~cmp, m), last_id_g(~K, ~V, ~cmp, m, g_m))


# ---- search: two field reads per level are the mirror's probes ----


# the order of a live node decides: descend (the rest by ih) or stop
def sr_o(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)) == True{} : Bool}, +k: K, +f: Nat, +i: Nat, +p: Nat, +ol: Bool, +c: Bool, +lf: Nat, +rt: Nat, +q: Nat, +key: K, +hy: {ST.nth_or(M.Node<K>, nl, i, M.Free{0n}) == M.N{c, lf, rt, q, key} : M.Node<K>}, ih: @+id2: Nat -> @+p2: Nat -> @+ol2: Bool -> {M.search_fin(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), M.search_fast(~K, ~V, ~cmp, f, k, p2, ol2, M.search_probe(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), id2, k))) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, f, k, id2, p2, ol2, MI.probe(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, id2, k))) : M.TreeMap<K, V, cmp> & M.Search}, +c0: Cmp) -> {M.search_fin(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), M.search_fast(~K, ~V, ~cmp, 1n+f, k, p, ol, (ST.nodes(~K, l, d, nl), (1n+i, Some{c0})))) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, 1n+f, k, 1n+i, p, ol, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, (M.N{c, lf, rt, q, key}, c0)))) : M.TreeMap<K, V, cmp> & M.Search}:
  match c0:
    case LT{}:
      %Equal.sym(M.NodeStore<K> & Nat, M.side_at(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), True{}, i), (ST.nodes(~K, l, d, nl), M.pick(Nat, True{}, M.nleft(~K, ST.nth_or(M.Node<K>, nl, i, M.Free{0n})), M.nright(~K, ST.nth_or(M.Node<K>, nl, i, M.Free{0n})))), side_ok(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, True{}, i)) : {M.search_fin(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), M.search_fast(~K, ~V, ~cmp, f, k, 1n+i, True{}, M.search_down2(~K, ~V, ~cmp, k, _))) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, 1n+f, k, 1n+i, p, ol, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, (M.N{c, lf, rt, q, key}, LT{})))) : M.TreeMap<K, V, cmp> & M.Search}
      %Equal.sym(M.Node<K>, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}), M.N{c, lf, rt, q, key}, hy) : {M.search_fin(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), M.search_fast(~K, ~V, ~cmp, f, k, 1n+i, True{}, M.search_probe(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), M.nleft(~K, _), k))) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, 1n+f, k, 1n+i, p, ol, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, (M.N{c, lf, rt, q, key}, LT{})))) : M.TreeMap<K, V, cmp> & M.Search}
      ih(lf, 1n+i, True{})
    case GT{}:
      %Equal.sym(M.NodeStore<K> & Nat, M.side_at(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), False{}, i), (ST.nodes(~K, l, d, nl), M.pick(Nat, False{}, M.nleft(~K, ST.nth_or(M.Node<K>, nl, i, M.Free{0n})), M.nright(~K, ST.nth_or(M.Node<K>, nl, i, M.Free{0n})))), side_ok(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, False{}, i)) : {M.search_fin(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), M.search_fast(~K, ~V, ~cmp, f, k, 1n+i, False{}, M.search_down2(~K, ~V, ~cmp, k, _))) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, 1n+f, k, 1n+i, p, ol, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, (M.N{c, lf, rt, q, key}, GT{})))) : M.TreeMap<K, V, cmp> & M.Search}
      %Equal.sym(M.Node<K>, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}), M.N{c, lf, rt, q, key}, hy) : {M.search_fin(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), M.search_fast(~K, ~V, ~cmp, f, k, 1n+i, False{}, M.search_probe(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), M.nright(~K, _), k))) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, 1n+f, k, 1n+i, p, ol, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, (M.N{c, lf, rt, q, key}, GT{})))) : M.TreeMap<K, V, cmp> & M.Search}
      ih(rt, 1n+i, False{})
    case EQ{}:
      {==}

def sr_c(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)) == True{} : Bool}, +k: K, +f: Nat, +i: Nat, +p: Nat, +ol: Bool, +c: Bool, +lf: Nat, +rt: Nat, +q: Nat, +key: K, +hy: {ST.nth_or(M.Node<K>, nl, i, M.Free{0n}) == M.N{c, lf, rt, q, key} : M.Node<K>}, ih: @+id2: Nat -> @+p2: Nat -> @+ol2: Bool -> {M.search_fin(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), M.search_fast(~K, ~V, ~cmp, f, k, p2, ol2, M.search_probe(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), id2, k))) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, f, k, id2, p2, ol2, MI.probe(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, id2, k))) : M.TreeMap<K, V, cmp> & M.Search}, +c0: Cmp, +hco: {cmp(k, key) == c0 : Cmp}) -> {M.search_fin(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), M.search_fast(~K, ~V, ~cmp, 1n+f, k, p, ol, (ST.nodes(~K, l, d, nl), (1n+i, Some{cmp(k, key)})))) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, 1n+f, k, 1n+i, p, ol, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, (M.N{c, lf, rt, q, key}, cmp(k, key))))) : M.TreeMap<K, V, cmp> & M.Search}:
  %Equal.sym(Cmp, cmp(k, key), c0, hco) : {M.search_fin(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), M.search_fast(~K, ~V, ~cmp, 1n+f, k, p, ol, (ST.nodes(~K, l, d, nl), (1n+i, Some{_})))) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, 1n+f, k, 1n+i, p, ol, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, (M.N{c, lf, rt, q, key}, _)))) : M.TreeMap<K, V, cmp> & M.Search}
  sr_o(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, hl, hd, hc, hp, k, f, i, p, ol, c, lf, rt, q, key, hy, ih, c0)

def sr_y(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)) == True{} : Bool}, +k: K, +f: Nat, +i: Nat, +p: Nat, +ol: Bool, +y: M.Node<K>, +hy: {ST.nth_or(M.Node<K>, nl, i, M.Free{0n}) == y : M.Node<K>}, ih: @+id2: Nat -> @+p2: Nat -> @+ol2: Bool -> {M.search_fin(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), M.search_fast(~K, ~V, ~cmp, f, k, p2, ol2, M.search_probe(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), id2, k))) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, f, k, id2, p2, ol2, MI.probe(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, id2, k))) : M.TreeMap<K, V, cmp> & M.Search}) -> {M.search_fin(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), M.search_fast(~K, ~V, ~cmp, 1n+f, k, p, ol, M.search_key(~K, ~V, ~cmp, 1n+i, k, (ST.nodes(~K, l, d, nl), M.nkey(~K, y))))) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, 1n+f, k, 1n+i, p, ol, MI.probe_node(~K, ~V, ~cmp, 1n+i, k, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, y)))) : M.TreeMap<K, V, cmp> & M.Search}:
  match y:
    case M.Free{z}:
      {==}
    case M.N{+c, +lf, +rt, +q, +key}:
      sr_c(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, hl, hd, hc, hp, k, f, i, p, ol, c, lf, rt, q, key, hy, ih, cmp(k, key), {==})

def s0_o(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)) == True{} : Bool}, +k: K, +i: Nat, +p: Nat, +ol: Bool, +c: Bool, +lf: Nat, +rt: Nat, +q: Nat, +key: K, +c0: Cmp) -> {M.search_fin(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), M.search_fast(~K, ~V, ~cmp, 0n, k, p, ol, (ST.nodes(~K, l, d, nl), (1n+i, Some{c0})))) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, 0n, k, 1n+i, p, ol, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, (M.N{c, lf, rt, q, key}, c0)))) : M.TreeMap<K, V, cmp> & M.Search}:
  match c0:
    case LT{}:
      {==}
    case GT{}:
      {==}
    case EQ{}:
      {==}

def s0_c(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)) == True{} : Bool}, +k: K, +i: Nat, +p: Nat, +ol: Bool, +c: Bool, +lf: Nat, +rt: Nat, +q: Nat, +key: K, +c0: Cmp, +hco: {cmp(k, key) == c0 : Cmp}) -> {M.search_fin(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), M.search_fast(~K, ~V, ~cmp, 0n, k, p, ol, (ST.nodes(~K, l, d, nl), (1n+i, Some{cmp(k, key)})))) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, 0n, k, 1n+i, p, ol, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, (M.N{c, lf, rt, q, key}, cmp(k, key))))) : M.TreeMap<K, V, cmp> & M.Search}:
  %Equal.sym(Cmp, cmp(k, key), c0, hco) : {M.search_fin(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), M.search_fast(~K, ~V, ~cmp, 0n, k, p, ol, (ST.nodes(~K, l, d, nl), (1n+i, Some{_})))) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, 0n, k, 1n+i, p, ol, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, (M.N{c, lf, rt, q, key}, _)))) : M.TreeMap<K, V, cmp> & M.Search}
  s0_o(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, hl, hd, hc, hp, k, i, p, ol, c, lf, rt, q, key, c0)

def s0_y(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)) == True{} : Bool}, +k: K, +i: Nat, +p: Nat, +ol: Bool, +y: M.Node<K>) -> {M.search_fin(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), M.search_fast(~K, ~V, ~cmp, 0n, k, p, ol, M.search_key(~K, ~V, ~cmp, 1n+i, k, (ST.nodes(~K, l, d, nl), M.nkey(~K, y))))) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, 0n, k, 1n+i, p, ol, MI.probe_node(~K, ~V, ~cmp, 1n+i, k, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, y)))) : M.TreeMap<K, V, cmp> & M.Search}:
  match y:
    case M.Free{z}:
      {==}
    case M.N{+c, +lf, +rt, +q, +key}:
      s0_c(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, hl, hd, hc, hp, k, i, p, ol, c, lf, rt, q, key, cmp(k, key), {==})

# the fast loop, the store put back into the map, is the mirror's loop
def sr(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)) == True{} : Bool}, +k: K, +fuel: Nat, +id: Nat, +p: Nat, +ol: Bool) -> {M.search_fin(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), M.search_fast(~K, ~V, ~cmp, fuel, k, p, ol, M.search_probe(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), id, k))) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, fuel, k, id, p, ol, MI.probe(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, id, k))) : M.TreeMap<K, V, cmp> & M.Search}:
  match fuel id:
    case 0n 0n:
      {==}
    case 0n 1n+ +i:
      %Equal.sym(M.NodeStore<K> & Maybe<&2, K>, M.ns_key_at(~K, ST.nodes(~K, l, d, nl), i), (ST.nodes(~K, l, d, nl), M.nkey(~K, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}))), NSL.key_at_ok(~K, l, d, nl, hl, hd, hc, i)) : {M.search_fin(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), M.search_fast(~K, ~V, ~cmp, 0n, k, p, ol, M.search_key(~K, ~V, ~cmp, 1n+i, k, _))) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, 0n, k, 1n+i, p, ol, MI.probe_node(~K, ~V, ~cmp, 1n+i, k, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}))))) : M.TreeMap<K, V, cmp> & M.Search}
      s0_y(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, hl, hd, hc, hp, k, i, p, ol, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}))
    case 1n+f 0n:
      {==}
    case 1n+ +f 1n+ +i:
      %Equal.sym(M.NodeStore<K> & Maybe<&2, K>, M.ns_key_at(~K, ST.nodes(~K, l, d, nl), i), (ST.nodes(~K, l, d, nl), M.nkey(~K, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}))), NSL.key_at_ok(~K, l, d, nl, hl, hd, hc, i)) : {M.search_fin(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), M.search_fast(~K, ~V, ~cmp, 1n+f, k, p, ol, M.search_key(~K, ~V, ~cmp, 1n+i, k, _))) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, 1n+f, k, 1n+i, p, ol, MI.probe_node(~K, ~V, ~cmp, 1n+i, k, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}))))) : M.TreeMap<K, V, cmp> & M.Search}
      sr_y(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, hl, hd, hc, hp, k, f, i, p, ol, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}), {==}, id2 => p2 => ol2 => sr(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, hl, hd, hc, hp, k, f, id2, p2, ol2))

def search_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.search(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search(~K, ~V, ~cmp, m, k)) : M.TreeMap<K, V, cmp> & M.Search}:
  match m:
    case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl}:
      sr(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, L.and_left(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), k, 1n+n, root, 0n, False{})


def probe_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, (M.Node<K> & Cmp), MI.probe(~K, ~V, ~cmp, m, id, k)) == True{} : Bool}:
  probe_node_g(~K, ~V, ~cmp, id, k, MI.read(~K, ~V, ~cmp, m, id), read_g(~K, ~V, ~cmp, m, id, g_m))


def search_loop_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +fuel: Nat, +k: K, +id: Nat, +p: Nat, +on_left: Bool, st: ST.Sh<K, V> & (M.Node<K> & Cmp), +g_st: {MI.dgp(K, V, (M.Node<K> & Cmp), st) == True{} : Bool}) -> {MI.dgp(K, V, M.Search, MI.search_loop(~K, ~V, ~cmp, fuel, k, id, p, on_left, st)) == True{} : Bool}:
  match fuel st:
    case 0n Tuple{+px4, Tuple{M.Free{+px8}, LT{}}}:
      g_st
    case 0n Tuple{+px4, Tuple{M.Free{+px8}, EQ{}}}:
      g_st
    case 0n Tuple{+px4, Tuple{M.Free{+px8}, GT{}}}:
      g_st
    case 0n Tuple{+px4, Tuple{M.N{+px9, +px10, +px11, +px12, +px13}, LT{}}}:
      g_st
    case 0n Tuple{+px4, Tuple{M.N{+px9, +px10, +px11, +px12, +px13}, EQ{}}}:
      g_st
    case 0n Tuple{+px4, Tuple{M.N{+px9, +px10, +px11, +px12, +px13}, GT{}}}:
      g_st
    case 1n+ +px3 Tuple{+px14, Tuple{M.Free{+px18}, LT{}}}:
      g_st
    case 1n+ +px3 Tuple{+px14, Tuple{M.Free{+px18}, EQ{}}}:
      g_st
    case 1n+ +px3 Tuple{+px14, Tuple{M.Free{+px18}, GT{}}}:
      g_st
    case 1n+ +px3 Tuple{+px14, Tuple{M.N{+px19, +px20, +px21, +px22, +px23}, LT{}}}:
      search_loop_g(~K, ~V, ~cmp, px3, k, px20, id, True{}, MI.probe(~K, ~V, ~cmp, px14, px20, k), probe_g(~K, ~V, ~cmp, px14, px20, k, g_st))
    case 1n+ +px3 Tuple{+px14, Tuple{M.N{+px19, +px20, +px21, +px22, +px23}, GT{}}}:
      search_loop_g(~K, ~V, ~cmp, px3, k, px21, id, False{}, MI.probe(~K, ~V, ~cmp, px14, px21, k), probe_g(~K, ~V, ~cmp, px14, px21, k, g_st))
    case 1n+ +px3 Tuple{+px14, Tuple{M.N{+px19, +px20, +px21, +px22, +px23}, EQ{}}}:
      g_st

def search_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.Search, MI.search(~K, ~V, ~cmp, m, k)) == True{} : Bool}:
  match m:
    case ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}:
      search_loop_g(~K, ~V, ~cmp, 1n+n, k, root, 0n, False{}, MI.probe(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, root, k), probe_g(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, root, k, g_m))

def get_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, V>, MI.get(~K, ~V, ~cmp, m, k)) == True{} : Bool}:
  get_found_g(~K, ~V, ~cmp, MI.search(~K, ~V, ~cmp, m, k), search_g(~K, ~V, ~cmp, m, k, g_m))

def get_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.get(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k) == MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.get(~K, ~V, ~cmp, m, k)) : M.TreeMap<K, V, cmp> & Maybe<&2, V>}:
  %Equal.sym(M.TreeMap<K, V, cmp> & M.Search, M.search(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k), MI.rp(~K, ~V, ~cmp, M.Search, MI.search(~K, ~V, ~cmp, m, k)), search_s(~K, ~V, ~cmp, m, k, g_m)) : {M.get_found(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.get(~K, ~V, ~cmp, m, k)) : M.TreeMap<K, V, cmp> & Maybe<&2, V>}
  get_found_s(~K, ~V, ~cmp, MI.search(~K, ~V, ~cmp, m, k), search_g(~K, ~V, ~cmp, m, k, g_m))


def contains_key_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Bool, MI.contains_key(~K, ~V, ~cmp, m, k)) == True{} : Bool}:
  contains_found_g(~K, ~V, ~cmp, MI.search(~K, ~V, ~cmp, m, k), search_g(~K, ~V, ~cmp, m, k, g_m))

def contains_key_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.contains_key(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k) == MI.rp(~K, ~V, ~cmp, Bool, MI.contains_key(~K, ~V, ~cmp, m, k)) : M.TreeMap<K, V, cmp> & Bool}:
  %Equal.sym(M.TreeMap<K, V, cmp> & M.Search, M.search(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k), MI.rp(~K, ~V, ~cmp, M.Search, MI.search(~K, ~V, ~cmp, m, k)), search_s(~K, ~V, ~cmp, m, k, g_m)) : {M.contains_found(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Bool, MI.contains_key(~K, ~V, ~cmp, m, k)) : M.TreeMap<K, V, cmp> & Bool}
  contains_found_s(~K, ~V, ~cmp, MI.search(~K, ~V, ~cmp, m, k), search_g(~K, ~V, ~cmp, m, k, g_m))


# ---- extreme: the field walk is the mirror's node walk ----


def xe_eq(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +fuel: Nat, +fw: Bool, +id: Nat, +next: Nat) -> {MI.extreme_loop(~K, ~V, ~cmp, fuel, fw, id, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, next)) == (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, MI.ext_loop(~K, fuel, nl, fw, id, next)) : ST.Sh<K, V> & Nat}:
  match fuel next:
    case 0n 0n:
      {==}
    case 0n 1n+j:
      {==}
    case 1n+f 0n:
      {==}
    case 1n+f 1n+j:
      xe_eq(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, f, fw, 1n+j, M.child(~K, ST.nd(K, nl, 1n+j), fw))

def xe_0(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +fw: Bool) -> {M.extreme_start(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), n, 0n, fw) == (ST.nodes(~K, l, d, nl), MI.ext_loop(~K, 1n+n, nl, fw, 0n, M.child(~K, ST.nd(K, nl, 0n), fw))) : M.NodeStore<K> & Nat}:
  match fw:
    case True{}:
      {==}
    case False{}:
      {==}

def xe_n(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)) == True{} : Bool}, +id: Nat, +fw: Bool) -> {M.extreme_start(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), n, id, fw) == (ST.nodes(~K, l, d, nl), MI.ext_loop(~K, 1n+n, nl, fw, id, M.child(~K, ST.nd(K, nl, id), fw))) : M.NodeStore<K> & Nat}:
  match id:
    case 0n:
      xe_0(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, fw)
    case 1n+ +j:
      %Equal.sym(M.NodeStore<K> & Nat, M.extreme_at(~K, ~V, ~cmp, fw, ST.nodes(~K, l, d, nl), j), (ST.nodes(~K, l, d, nl), M.child(~K, ST.nth_or(M.Node<K>, nl, j, M.Free{0n}), fw)), ext_at(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, fw, j)) : {M.extreme_slots_loop(~K, ~V, ~cmp, 1n+n, fw, 1n+j, _) == (ST.nodes(~K, l, d, nl), MI.ext_loop(~K, 1n+n, nl, fw, 1n+j, M.child(~K, ST.nd(K, nl, 1n+j), fw))) : M.NodeStore<K> & Nat}
      esl(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, 1n+n, fw, 1n+j, M.child(~K, ST.nth_or(M.Node<K>, nl, j, M.Free{0n}), fw))

def extreme_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +forward: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.extreme(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id, forward) == MI.rp(~K, ~V, ~cmp, Nat, MI.extreme(~K, ~V, ~cmp, m, id, forward)) : M.TreeMap<K, V, cmp> & Nat}:
  match m:
    case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl}:
      %Equal.sym(ST.Sh<K, V> & Nat, MI.extreme(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, id, forward), (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, MI.ext_loop(~K, 1n+n, nl, forward, id, M.child(~K, ST.nd(K, nl, id), forward))), xe_eq(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, 1n+n, forward, id, M.child(~K, ST.nd(K, nl, id), forward))) : {M.extreme(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}), id, forward) == MI.rp(~K, ~V, ~cmp, Nat, _) : M.TreeMap<K, V, cmp> & Nat}
      %Equal.sym(M.NodeStore<K> & Nat, M.extreme_start(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), n, id, forward), (ST.nodes(~K, l, d, nl), MI.ext_loop(~K, 1n+n, nl, forward, id, M.child(~K, ST.nd(K, nl, id), forward))), xe_n(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, L.and_left(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), id, forward)) : {M.neighbor_slots_finish(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), _) == MI.rp(~K, ~V, ~cmp, Nat, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, MI.ext_loop(~K, 1n+n, nl, forward, id, M.child(~K, ST.nd(K, nl, id), forward)))) : M.TreeMap<K, V, cmp> & Nat}
      {==}

def extreme_probe_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +forward: Bool, r: ST.Sh<K, V> & M.Node<K>, +g_r: {MI.dgp(K, V, M.Node<K>, r) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.extreme_probe(~K, ~V, ~cmp, forward, r)) == True{} : Bool}:
  match r:
    case Tuple{+m, +node}:
      g_r

def extreme_loop_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +fuel: Nat, +forward: Bool, +id: Nat, st: ST.Sh<K, V> & Nat, +g_st: {MI.dgp(K, V, Nat, st) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.extreme_loop(~K, ~V, ~cmp, fuel, forward, id, st)) == True{} : Bool}:
  match fuel st:
    case 0n Tuple{+px4, 0n}:
      g_st
    case 0n Tuple{+px4, 1n+ +px6}:
      g_st
    case 1n+ +px3 Tuple{+px7, 0n}:
      g_st
    case 1n+ +px3 Tuple{+px7, 1n+ +px9}:
      extreme_loop_g(~K, ~V, ~cmp, px3, forward, 1n+px9, MI.extreme_probe(~K, ~V, ~cmp, forward, MI.read(~K, ~V, ~cmp, px7, 1n+px9)), extreme_probe_g(~K, ~V, ~cmp, forward, MI.read(~K, ~V, ~cmp, px7, 1n+px9), read_g(~K, ~V, ~cmp, px7, 1n+px9, g_st)))

def extreme_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +forward: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.extreme(~K, ~V, ~cmp, m, id, forward)) == True{} : Bool}:
  match m:
    case ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}:
      extreme_loop_g(~K, ~V, ~cmp, 1n+n, forward, id, MI.extreme_probe(~K, ~V, ~cmp, forward, MI.read(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, id)), extreme_probe_g(~K, ~V, ~cmp, forward, MI.read(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, id), read_g(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, id, g_m)))

def replace_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +v: V, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, V>, MI.replace(~K, ~V, ~cmp, m, k, v)) == True{} : Bool}:
  replace_found_g(~K, ~V, ~cmp, v, MI.search(~K, ~V, ~cmp, m, k), search_g(~K, ~V, ~cmp, m, k, g_m))

def replace_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +v: V, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.replace(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k, v) == MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.replace(~K, ~V, ~cmp, m, k, v)) : M.TreeMap<K, V, cmp> & Maybe<&2, V>}:
  %Equal.sym(M.TreeMap<K, V, cmp> & M.Search, M.search(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k), MI.rp(~K, ~V, ~cmp, M.Search, MI.search(~K, ~V, ~cmp, m, k)), search_s(~K, ~V, ~cmp, m, k, g_m)) : {M.replace_found(~K, ~V, ~cmp, v, _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.replace(~K, ~V, ~cmp, m, k, v)) : M.TreeMap<K, V, cmp> & Maybe<&2, V>}
  replace_found_s(~K, ~V, ~cmp, v, MI.search(~K, ~V, ~cmp, m, k), search_g(~K, ~V, ~cmp, m, k, g_m))


def iterator_reseek_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +k: Maybe<&2, K>, +lower: M.Bound<K>, +upper: M.Bound<K>, +forward: Bool, r: ST.Sh<K, V> & Maybe<&2, V>, +g_r: {MI.dgp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {MI.dgcp(K, V, Maybe<&2, V>, MI.iterator_reseek(~K, ~V, ~cmp, k, lower, upper, forward, r)) == True{} : Bool}:
  match k r:
    case None{} Tuple{+px4, +px5}:
      g_r
    case Some{+px3} Tuple{+px6, +px7}:
      iterator_relocated_g(~K, ~V, ~cmp, lower, upper, forward, px7, MI.search(~K, ~V, ~cmp, px6, px3), search_g(~K, ~V, ~cmp, px6, px3, g_r))

def iterator_reseek_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +k: Maybe<&2, K>, +lower: M.Bound<K>, +upper: M.Bound<K>, +forward: Bool, r: ST.Sh<K, V> & Maybe<&2, V>, +g_r: {MI.dgp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {M.iterator_reseek(~K, ~V, ~cmp, k, lower, upper, forward, MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, r)) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, V>, MI.iterator_reseek(~K, ~V, ~cmp, k, lower, upper, forward, r)) : M.Cursor<K, V, cmp> & Maybe<&2, V>}:
  match k r:
    case None{} Tuple{+px4, +px5}:
      {==}
    case Some{+px3} Tuple{+px6, +px7}:
      %Equal.sym(M.TreeMap<K, V, cmp> & M.Search, M.search(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, px6), px3), MI.rp(~K, ~V, ~cmp, M.Search, MI.search(~K, ~V, ~cmp, px6, px3)), search_s(~K, ~V, ~cmp, px6, px3, g_r)) : {M.iterator_relocated(~K, ~V, ~cmp, lower, upper, forward, px7, _) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, V>, MI.iterator_reseek(~K, ~V, ~cmp, Some{px3}, lower, upper, forward, Tuple{px6, px7})) : M.Cursor<K, V, cmp> & Maybe<&2, V>}
      iterator_relocated_s(~K, ~V, ~cmp, lower, upper, forward, px7, MI.search(~K, ~V, ~cmp, px6, px3), search_g(~K, ~V, ~cmp, px6, px3, g_r))


def replace_if_equal_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~eq: V -> V -> Bool, +m: ST.Sh<K, V>, +k: K, +expected: V, +replacement: V, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Bool, MI.replace_if_equal(~K, ~V, ~cmp, ~eq, m, k, expected, replacement)) == True{} : Bool}:
  replace_if_found_g(~K, ~V, ~cmp, ~eq, expected, replacement, MI.search(~K, ~V, ~cmp, m, k), search_g(~K, ~V, ~cmp, m, k, g_m))

def replace_if_equal_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~eq: V -> V -> Bool, +m: ST.Sh<K, V>, +k: K, +expected: V, +replacement: V, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.replace_if_equal(~K, ~V, ~cmp, ~eq, ST.real(~K, ~V, ~cmp, m), k, expected, replacement) == MI.rp(~K, ~V, ~cmp, Bool, MI.replace_if_equal(~K, ~V, ~cmp, ~eq, m, k, expected, replacement)) : M.TreeMap<K, V, cmp> & Bool}:
  %Equal.sym(M.TreeMap<K, V, cmp> & M.Search, M.search(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k), MI.rp(~K, ~V, ~cmp, M.Search, MI.search(~K, ~V, ~cmp, m, k)), search_s(~K, ~V, ~cmp, m, k, g_m)) : {M.replace_if_found(~K, ~V, ~cmp, ~eq, expected, replacement, _) == MI.rp(~K, ~V, ~cmp, Bool, MI.replace_if_equal(~K, ~V, ~cmp, ~eq, m, k, expected, replacement)) : M.TreeMap<K, V, cmp> & Bool}
  replace_if_found_s(~K, ~V, ~cmp, ~eq, expected, replacement, MI.search(~K, ~V, ~cmp, m, k), search_g(~K, ~V, ~cmp, m, k, g_m))


def rotate_left_2_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, +xn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dg(K, V, MI.rotate_left_2(~K, ~V, ~cmp, x, xn, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m2, +yn}:
      rotate_left_3_g(~K, ~V, ~cmp, x, xn, yn, MI.read(~K, ~V, ~cmp, m2, M.node_parent(~K, xn)), read_g(~K, ~V, ~cmp, m2, M.node_parent(~K, xn), g_pair_result))

def rotate_left_2_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, +xn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.rotate_left_2(~K, ~V, ~cmp, x, xn, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == ST.real(~K, ~V, ~cmp, MI.rotate_left_2(~K, ~V, ~cmp, x, xn, pair_result)) : M.TreeMap<K, V, cmp>}:
  match pair_result:
    case Tuple{+m2, +yn}:
      %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m2), M.node_parent(~K, xn)), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m2, M.node_parent(~K, xn))), read_s(~K, ~V, ~cmp, m2, M.node_parent(~K, xn), g_pair_result)) : {M.rotate_left_3(~K, ~V, ~cmp, x, xn, yn, _) == ST.real(~K, ~V, ~cmp, MI.rotate_left_2(~K, ~V, ~cmp, x, xn, Tuple{m2, yn})) : M.TreeMap<K, V, cmp>}
      rotate_left_3_s(~K, ~V, ~cmp, x, xn, yn, MI.read(~K, ~V, ~cmp, m2, M.node_parent(~K, xn)), read_g(~K, ~V, ~cmp, m2, M.node_parent(~K, xn), g_pair_result))


def rotate_right_2_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, +xn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dg(K, V, MI.rotate_right_2(~K, ~V, ~cmp, x, xn, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m2, +yn}:
      rotate_right_3_g(~K, ~V, ~cmp, x, xn, yn, MI.read(~K, ~V, ~cmp, m2, M.node_parent(~K, xn)), read_g(~K, ~V, ~cmp, m2, M.node_parent(~K, xn), g_pair_result))

def rotate_right_2_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, +xn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.rotate_right_2(~K, ~V, ~cmp, x, xn, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == ST.real(~K, ~V, ~cmp, MI.rotate_right_2(~K, ~V, ~cmp, x, xn, pair_result)) : M.TreeMap<K, V, cmp>}:
  match pair_result:
    case Tuple{+m2, +yn}:
      %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m2), M.node_parent(~K, xn)), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m2, M.node_parent(~K, xn))), read_s(~K, ~V, ~cmp, m2, M.node_parent(~K, xn), g_pair_result)) : {M.rotate_right_3(~K, ~V, ~cmp, x, xn, yn, _) == ST.real(~K, ~V, ~cmp, MI.rotate_right_2(~K, ~V, ~cmp, x, xn, Tuple{m2, yn})) : M.TreeMap<K, V, cmp>}
      rotate_right_3_s(~K, ~V, ~cmp, x, xn, yn, MI.read(~K, ~V, ~cmp, m2, M.node_parent(~K, xn)), read_g(~K, ~V, ~cmp, m2, M.node_parent(~K, xn), g_pair_result))

def probe_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.probe(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id, k) == MI.rp(~K, ~V, ~cmp, (M.Node<K> & Cmp), MI.probe(~K, ~V, ~cmp, m, id, k)) : M.TreeMap<K, V, cmp> & (M.Node<K> & Cmp)}:
  %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m, id)), read_s(~K, ~V, ~cmp, m, id, g_m)) : {M.probe_node(~K, ~V, ~cmp, id, k, _) == MI.rp(~K, ~V, ~cmp, (M.Node<K> & Cmp), MI.probe(~K, ~V, ~cmp, m, id, k)) : M.TreeMap<K, V, cmp> & (M.Node<K> & Cmp)}
  probe_node_s(~K, ~V, ~cmp, id, k, MI.read(~K, ~V, ~cmp, m, id), read_g(~K, ~V, ~cmp, m, id, g_m))


def ascend_loop_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +fuel: Nat, +forward: Bool, st: ST.Sh<K, V> & M.Ascend, +g_st: {MI.dgp(K, V, M.Ascend, st) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.ascend_loop(~K, ~V, ~cmp, fuel, forward, st)) == True{} : Bool}:
  match fuel st:
    case 0n Tuple{+px4, +px5}:
      g_st
    case 1n+ +px3 Tuple{+px6, M.Ascend{+px8, +px9, True{}}}:
      g_st
    case 1n+ +px3 Tuple{+px6, M.Ascend{+px8, +px9, False{}}}:
      ascend_loop_g(~K, ~V, ~cmp, px3, forward, MI.ascend_step_node(~K, ~V, ~cmp, px8, px9, forward, MI.read(~K, ~V, ~cmp, px6, px9)), ascend_step_node_g(~K, ~V, ~cmp, px8, px9, forward, MI.read(~K, ~V, ~cmp, px6, px9), read_g(~K, ~V, ~cmp, px6, px9, g_st)))

def ascend_loop_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +fuel: Nat, +forward: Bool, st: ST.Sh<K, V> & M.Ascend, +g_st: {MI.dgp(K, V, M.Ascend, st) == True{} : Bool}) -> {M.ascend_loop(~K, ~V, ~cmp, fuel, forward, MI.rp(~K, ~V, ~cmp, M.Ascend, st)) == MI.rp(~K, ~V, ~cmp, Nat, MI.ascend_loop(~K, ~V, ~cmp, fuel, forward, st)) : M.TreeMap<K, V, cmp> & Nat}:
  match fuel st:
    case 0n Tuple{+px4, +px5}:
      {==}
    case 1n+ +px3 Tuple{+px6, M.Ascend{+px8, +px9, True{}}}:
      {==}
    case 1n+ +px3 Tuple{+px6, M.Ascend{+px8, +px9, False{}}}:
      %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, px6), px9), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, px6, px9)), read_s(~K, ~V, ~cmp, px6, px9, g_st)) : {M.ascend_loop(~K, ~V, ~cmp, px3, forward, M.ascend_step_node(~K, ~V, ~cmp, px8, px9, forward, _)) == MI.rp(~K, ~V, ~cmp, Nat, MI.ascend_loop(~K, ~V, ~cmp, 1n+ px3, forward, Tuple{px6, M.Ascend{px8, px9, False{}}})) : M.TreeMap<K, V, cmp> & Nat}
      %Equal.sym(M.TreeMap<K, V, cmp> & M.Ascend, M.ascend_step_node(~K, ~V, ~cmp, px8, px9, forward, MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, px6, px9))), MI.rp(~K, ~V, ~cmp, M.Ascend, MI.ascend_step_node(~K, ~V, ~cmp, px8, px9, forward, MI.read(~K, ~V, ~cmp, px6, px9))), ascend_step_node_s(~K, ~V, ~cmp, px8, px9, forward, MI.read(~K, ~V, ~cmp, px6, px9), read_g(~K, ~V, ~cmp, px6, px9, g_st))) : {M.ascend_loop(~K, ~V, ~cmp, px3, forward, _) == MI.rp(~K, ~V, ~cmp, Nat, MI.ascend_loop(~K, ~V, ~cmp, 1n+ px3, forward, Tuple{px6, M.Ascend{px8, px9, False{}}})) : M.TreeMap<K, V, cmp> & Nat}
      ascend_loop_s(~K, ~V, ~cmp, px3, forward, MI.ascend_step_node(~K, ~V, ~cmp, px8, px9, forward, MI.read(~K, ~V, ~cmp, px6, px9)), ascend_step_node_g(~K, ~V, ~cmp, px8, px9, forward, MI.read(~K, ~V, ~cmp, px6, px9), read_g(~K, ~V, ~cmp, px6, px9, g_st)))


def neighbor_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +forward: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.neighbor(~K, ~V, ~cmp, m, id, forward)) == True{} : Bool}:
  neighbor_node_g(~K, ~V, ~cmp, id, forward, MI.read(~K, ~V, ~cmp, m, id), read_g(~K, ~V, ~cmp, m, id, g_m))

def neighbor_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +forward: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.neighbor(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id, forward) == MI.rp(~K, ~V, ~cmp, Nat, MI.neighbor(~K, ~V, ~cmp, m, id, forward)) : M.TreeMap<K, V, cmp> & Nat}:
  %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m, id)), read_s(~K, ~V, ~cmp, m, id, g_m)) : {M.neighbor_node(~K, ~V, ~cmp, id, forward, _) == MI.rp(~K, ~V, ~cmp, Nat, MI.neighbor(~K, ~V, ~cmp, m, id, forward)) : M.TreeMap<K, V, cmp> & Nat}
  neighbor_node_s(~K, ~V, ~cmp, id, forward, MI.read(~K, ~V, ~cmp, m, id), read_g(~K, ~V, ~cmp, m, id, g_m))


def set_key_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.set_key(~K, ~V, ~cmp, m, id, k)) == True{} : Bool}:
  set_key_1_g(~K, ~V, ~cmp, id, k, MI.read(~K, ~V, ~cmp, m, id), read_g(~K, ~V, ~cmp, m, id, g_m))

def set_key_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.set_key(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id, k) == ST.real(~K, ~V, ~cmp, MI.set_key(~K, ~V, ~cmp, m, id, k)) : M.TreeMap<K, V, cmp>}:
  %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m, id)), read_s(~K, ~V, ~cmp, m, id, g_m)) : {M.set_key_1(~K, ~V, ~cmp, id, k, _) == ST.real(~K, ~V, ~cmp, MI.set_key(~K, ~V, ~cmp, m, id, k)) : M.TreeMap<K, V, cmp>}
  set_key_1_s(~K, ~V, ~cmp, id, k, MI.read(~K, ~V, ~cmp, m, id), read_g(~K, ~V, ~cmp, m, id, g_m))


def refresh_ends_2_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +r: Nat, pair_result: ST.Sh<K, V> & Nat, +g_pair_result: {MI.dgp(K, V, Nat, pair_result) == True{} : Bool}) -> {MI.dg(K, V, MI.refresh_ends_2(~K, ~V, ~cmp, r, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m2, +lo}:
      refresh_ends_3_g(~K, ~V, ~cmp, lo, MI.extreme(~K, ~V, ~cmp, m2, r, True{}), extreme_g(~K, ~V, ~cmp, m2, r, True{}, g_pair_result))

def refresh_ends_2_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +r: Nat, pair_result: ST.Sh<K, V> & Nat, +g_pair_result: {MI.dgp(K, V, Nat, pair_result) == True{} : Bool}) -> {M.refresh_ends_2(~K, ~V, ~cmp, r, MI.rp(~K, ~V, ~cmp, Nat, pair_result)) == ST.real(~K, ~V, ~cmp, MI.refresh_ends_2(~K, ~V, ~cmp, r, pair_result)) : M.TreeMap<K, V, cmp>}:
  match pair_result:
    case Tuple{+m2, +lo}:
      %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.extreme(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m2), r, True{}), MI.rp(~K, ~V, ~cmp, Nat, MI.extreme(~K, ~V, ~cmp, m2, r, True{})), extreme_s(~K, ~V, ~cmp, m2, r, True{}, g_pair_result)) : {M.refresh_ends_3(~K, ~V, ~cmp, lo, _) == ST.real(~K, ~V, ~cmp, MI.refresh_ends_2(~K, ~V, ~cmp, r, Tuple{m2, lo})) : M.TreeMap<K, V, cmp>}
      refresh_ends_3_s(~K, ~V, ~cmp, lo, MI.extreme(~K, ~V, ~cmp, m2, r, True{}), extreme_g(~K, ~V, ~cmp, m2, r, True{}, g_pair_result))


def key_id_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh<K, V> & Nat, +g_r: {MI.dgp(K, V, Nat, r) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, K>, MI.key_id(~K, ~V, ~cmp, r)) == True{} : Bool}:
  match r:
    case Tuple{+m, +id}:
      key_finish_g(~K, ~V, ~cmp, MI.read(~K, ~V, ~cmp, m, id), read_g(~K, ~V, ~cmp, m, id, g_r))

def key_id_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh<K, V> & Nat, +g_r: {MI.dgp(K, V, Nat, r) == True{} : Bool}) -> {M.key_id(~K, ~V, ~cmp, MI.rp(~K, ~V, ~cmp, Nat, r)) == MI.rp(~K, ~V, ~cmp, Maybe<&2, K>, MI.key_id(~K, ~V, ~cmp, r)) : M.TreeMap<K, V, cmp> & Maybe<&2, K>}:
  match r:
    case Tuple{+m, +id}:
      %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m, id)), read_s(~K, ~V, ~cmp, m, id, g_r)) : {M.key_finish(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, K>, MI.key_id(~K, ~V, ~cmp, Tuple{m, id})) : M.TreeMap<K, V, cmp> & Maybe<&2, K>}
      key_finish_s(~K, ~V, ~cmp, MI.read(~K, ~V, ~cmp, m, id), read_g(~K, ~V, ~cmp, m, id, g_r))


def get_or_default_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +fallback: V, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, V, MI.get_or_default(~K, ~V, ~cmp, m, k, fallback)) == True{} : Bool}:
  default_value_g(~K, ~V, ~cmp, fallback, MI.get(~K, ~V, ~cmp, m, k), get_g(~K, ~V, ~cmp, m, k, g_m))

def get_or_default_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +fallback: V, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.get_or_default(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k, fallback) == MI.rp(~K, ~V, ~cmp, V, MI.get_or_default(~K, ~V, ~cmp, m, k, fallback)) : M.TreeMap<K, V, cmp> & V}:
  %Equal.sym(M.TreeMap<K, V, cmp> & Maybe<&2, V>, M.get(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k), MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.get(~K, ~V, ~cmp, m, k)), get_s(~K, ~V, ~cmp, m, k, g_m)) : {M.default_value(~K, ~V, ~cmp, fallback, _) == MI.rp(~K, ~V, ~cmp, V, MI.get_or_default(~K, ~V, ~cmp, m, k, fallback)) : M.TreeMap<K, V, cmp> & V}
  default_value_s(~K, ~V, ~cmp, fallback, MI.get(~K, ~V, ~cmp, m, k), get_g(~K, ~V, ~cmp, m, k, g_m))


def view_get_checked_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +lower: M.Bound<K>, +upper: M.Bound<K>, +descending: Bool, +valid: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgvp(K, V, Maybe<&2, V>, MI.view_get_checked(~K, ~V, ~cmp, m, k, lower, upper, descending, valid)) == True{} : Bool}:
  match valid:
    case True{}:
      view_value_g(~K, ~V, ~cmp, lower, upper, descending, MI.get(~K, ~V, ~cmp, m, k), get_g(~K, ~V, ~cmp, m, k, g_m))
    case False{}:
      g_m

def view_get_checked_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +lower: M.Bound<K>, +upper: M.Bound<K>, +descending: Bool, +valid: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.view_get_checked(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k, lower, upper, descending, valid) == MI.rvp(~K, ~V, ~cmp, Maybe<&2, V>, MI.view_get_checked(~K, ~V, ~cmp, m, k, lower, upper, descending, valid)) : M.View<K, V, cmp> & Maybe<&2, V>}:
  match valid:
    case True{}:
      %Equal.sym(M.TreeMap<K, V, cmp> & Maybe<&2, V>, M.get(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k), MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.get(~K, ~V, ~cmp, m, k)), get_s(~K, ~V, ~cmp, m, k, g_m)) : {M.view_value(~K, ~V, ~cmp, lower, upper, descending, _) == MI.rvp(~K, ~V, ~cmp, Maybe<&2, V>, MI.view_get_checked(~K, ~V, ~cmp, m, k, lower, upper, descending, True{})) : M.View<K, V, cmp> & Maybe<&2, V>}
      view_value_s(~K, ~V, ~cmp, lower, upper, descending, MI.get(~K, ~V, ~cmp, m, k), get_g(~K, ~V, ~cmp, m, k, g_m))
    case False{}:
      {==}


def iterator_has_next_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +cursor: MI.MCursor<K, V>, +g_cursor: {MI.dgc(K, V, cursor) == True{} : Bool}) -> {MI.dgcp(K, V, Bool, MI.iterator_has_next(~K, ~V, ~cmp, cursor)) == True{} : Bool}:
  match cursor:
    case MI.MC{+m, +next, +current, +lower, +upper, +forward}:
      iterator_has_checked_g(~K, ~V, ~cmp, next, current, lower, upper, forward, MI.read(~K, ~V, ~cmp, m, next), read_g(~K, ~V, ~cmp, m, next, g_cursor))

def iterator_has_next_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +cursor: MI.MCursor<K, V>, +g_cursor: {MI.dgc(K, V, cursor) == True{} : Bool}) -> {M.iterator_has_next(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, cursor)) == MI.rcp(~K, ~V, ~cmp, Bool, MI.iterator_has_next(~K, ~V, ~cmp, cursor)) : M.Cursor<K, V, cmp> & Bool}:
  match cursor:
    case MI.MC{+m, +next, +current, +lower, +upper, +forward}:
      %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), next), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m, next)), read_s(~K, ~V, ~cmp, m, next, g_cursor)) : {M.iterator_has_checked(~K, ~V, ~cmp, next, current, lower, upper, forward, _) == MI.rcp(~K, ~V, ~cmp, Bool, MI.iterator_has_next(~K, ~V, ~cmp, MI.MC{m, next, current, lower, upper, forward})) : M.Cursor<K, V, cmp> & Bool}
      iterator_has_checked_s(~K, ~V, ~cmp, next, current, lower, upper, forward, MI.read(~K, ~V, ~cmp, m, next), read_g(~K, ~V, ~cmp, m, next, g_cursor))


def rotate_left_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dg(K, V, MI.rotate_left_1(~K, ~V, ~cmp, x, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m1, +xn}:
      rotate_left_2_g(~K, ~V, ~cmp, x, xn, MI.read(~K, ~V, ~cmp, m1, M.node_right(~K, xn)), read_g(~K, ~V, ~cmp, m1, M.node_right(~K, xn), g_pair_result))

def rotate_left_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.rotate_left_1(~K, ~V, ~cmp, x, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == ST.real(~K, ~V, ~cmp, MI.rotate_left_1(~K, ~V, ~cmp, x, pair_result)) : M.TreeMap<K, V, cmp>}:
  match pair_result:
    case Tuple{+m1, +xn}:
      %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m1), M.node_right(~K, xn)), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m1, M.node_right(~K, xn))), read_s(~K, ~V, ~cmp, m1, M.node_right(~K, xn), g_pair_result)) : {M.rotate_left_2(~K, ~V, ~cmp, x, xn, _) == ST.real(~K, ~V, ~cmp, MI.rotate_left_1(~K, ~V, ~cmp, x, Tuple{m1, xn})) : M.TreeMap<K, V, cmp>}
      rotate_left_2_s(~K, ~V, ~cmp, x, xn, MI.read(~K, ~V, ~cmp, m1, M.node_right(~K, xn)), read_g(~K, ~V, ~cmp, m1, M.node_right(~K, xn), g_pair_result))


def rotate_right_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dg(K, V, MI.rotate_right_1(~K, ~V, ~cmp, x, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m1, +xn}:
      rotate_right_2_g(~K, ~V, ~cmp, x, xn, MI.read(~K, ~V, ~cmp, m1, M.node_left(~K, xn)), read_g(~K, ~V, ~cmp, m1, M.node_left(~K, xn), g_pair_result))

def rotate_right_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.rotate_right_1(~K, ~V, ~cmp, x, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == ST.real(~K, ~V, ~cmp, MI.rotate_right_1(~K, ~V, ~cmp, x, pair_result)) : M.TreeMap<K, V, cmp>}:
  match pair_result:
    case Tuple{+m1, +xn}:
      %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m1), M.node_left(~K, xn)), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m1, M.node_left(~K, xn))), read_s(~K, ~V, ~cmp, m1, M.node_left(~K, xn), g_pair_result)) : {M.rotate_right_2(~K, ~V, ~cmp, x, xn, _) == ST.real(~K, ~V, ~cmp, MI.rotate_right_1(~K, ~V, ~cmp, x, Tuple{m1, xn})) : M.TreeMap<K, V, cmp>}
      rotate_right_2_s(~K, ~V, ~cmp, x, xn, MI.read(~K, ~V, ~cmp, m1, M.node_left(~K, xn)), read_g(~K, ~V, ~cmp, m1, M.node_left(~K, xn), g_pair_result))

def search_loop_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +fuel: Nat, +k: K, +id: Nat, +p: Nat, +on_left: Bool, st: ST.Sh<K, V> & (M.Node<K> & Cmp), +g_st: {MI.dgp(K, V, (M.Node<K> & Cmp), st) == True{} : Bool}) -> {M.search_loop(~K, ~V, ~cmp, fuel, k, id, p, on_left, MI.rp(~K, ~V, ~cmp, (M.Node<K> & Cmp), st)) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, fuel, k, id, p, on_left, st)) : M.TreeMap<K, V, cmp> & M.Search}:
  match fuel st:
    case 0n Tuple{+px4, Tuple{M.Free{+px8}, LT{}}}:
      {==}
    case 0n Tuple{+px4, Tuple{M.Free{+px8}, EQ{}}}:
      {==}
    case 0n Tuple{+px4, Tuple{M.Free{+px8}, GT{}}}:
      {==}
    case 0n Tuple{+px4, Tuple{M.N{+px9, +px10, +px11, +px12, +px13}, LT{}}}:
      {==}
    case 0n Tuple{+px4, Tuple{M.N{+px9, +px10, +px11, +px12, +px13}, EQ{}}}:
      {==}
    case 0n Tuple{+px4, Tuple{M.N{+px9, +px10, +px11, +px12, +px13}, GT{}}}:
      {==}
    case 1n+ +px3 Tuple{+px14, Tuple{M.Free{+px18}, LT{}}}:
      {==}
    case 1n+ +px3 Tuple{+px14, Tuple{M.Free{+px18}, EQ{}}}:
      {==}
    case 1n+ +px3 Tuple{+px14, Tuple{M.Free{+px18}, GT{}}}:
      {==}
    case 1n+ +px3 Tuple{+px14, Tuple{M.N{+px19, +px20, +px21, +px22, +px23}, LT{}}}:
      %Equal.sym(M.TreeMap<K, V, cmp> & (M.Node<K> & Cmp), M.probe(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, px14), px20, k), MI.rp(~K, ~V, ~cmp, (M.Node<K> & Cmp), MI.probe(~K, ~V, ~cmp, px14, px20, k)), probe_s(~K, ~V, ~cmp, px14, px20, k, g_st)) : {M.search_loop(~K, ~V, ~cmp, px3, k, px20, id, True{}, _) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, 1n+ px3, k, id, p, on_left, Tuple{px14, Tuple{M.N{px19, px20, px21, px22, px23}, LT{}}})) : M.TreeMap<K, V, cmp> & M.Search}
      search_loop_s(~K, ~V, ~cmp, px3, k, px20, id, True{}, MI.probe(~K, ~V, ~cmp, px14, px20, k), probe_g(~K, ~V, ~cmp, px14, px20, k, g_st))
    case 1n+ +px3 Tuple{+px14, Tuple{M.N{+px19, +px20, +px21, +px22, +px23}, GT{}}}:
      %Equal.sym(M.TreeMap<K, V, cmp> & (M.Node<K> & Cmp), M.probe(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, px14), px21, k), MI.rp(~K, ~V, ~cmp, (M.Node<K> & Cmp), MI.probe(~K, ~V, ~cmp, px14, px21, k)), probe_s(~K, ~V, ~cmp, px14, px21, k, g_st)) : {M.search_loop(~K, ~V, ~cmp, px3, k, px21, id, False{}, _) == MI.rp(~K, ~V, ~cmp, M.Search, MI.search_loop(~K, ~V, ~cmp, 1n+ px3, k, id, p, on_left, Tuple{px14, Tuple{M.N{px19, px20, px21, px22, px23}, GT{}}})) : M.TreeMap<K, V, cmp> & M.Search}
      search_loop_s(~K, ~V, ~cmp, px3, k, px21, id, False{}, MI.probe(~K, ~V, ~cmp, px14, px21, k), probe_g(~K, ~V, ~cmp, px14, px21, k, g_st))
    case 1n+ +px3 Tuple{+px14, Tuple{M.N{+px19, +px20, +px21, +px22, +px23}, EQ{}}}:
      {==}


def copy_key_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +target: Nat, +node: M.Node<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.copy_key(~K, ~V, ~cmp, m, target, node)) == True{} : Bool}:
  match node:
    case M.Free{+px2}:
      g_m
    case M.N{+px3, +px4, +px5, +px6, +px7}:
      set_key_g(~K, ~V, ~cmp, m, target, px7, g_m)

def copy_key_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +target: Nat, +node: M.Node<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.copy_key(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), target, node) == ST.real(~K, ~V, ~cmp, MI.copy_key(~K, ~V, ~cmp, m, target, node)) : M.TreeMap<K, V, cmp>}:
  match node:
    case M.Free{+px2}:
      {==}
    case M.N{+px3, +px4, +px5, +px6, +px7}:
      set_key_s(~K, ~V, ~cmp, m, target, px7, g_m)


def refresh_ends_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, pair_result: ST.Sh<K, V> & Nat, +g_pair_result: {MI.dgp(K, V, Nat, pair_result) == True{} : Bool}) -> {MI.dg(K, V, MI.refresh_ends_1(~K, ~V, ~cmp, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m1, +r}:
      refresh_ends_2_g(~K, ~V, ~cmp, r, MI.extreme(~K, ~V, ~cmp, m1, r, False{}), extreme_g(~K, ~V, ~cmp, m1, r, False{}, g_pair_result))

def refresh_ends_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, pair_result: ST.Sh<K, V> & Nat, +g_pair_result: {MI.dgp(K, V, Nat, pair_result) == True{} : Bool}) -> {M.refresh_ends_1(~K, ~V, ~cmp, MI.rp(~K, ~V, ~cmp, Nat, pair_result)) == ST.real(~K, ~V, ~cmp, MI.refresh_ends_1(~K, ~V, ~cmp, pair_result)) : M.TreeMap<K, V, cmp>}:
  match pair_result:
    case Tuple{+m1, +r}:
      %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.extreme(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m1), r, False{}), MI.rp(~K, ~V, ~cmp, Nat, MI.extreme(~K, ~V, ~cmp, m1, r, False{})), extreme_s(~K, ~V, ~cmp, m1, r, False{}, g_pair_result)) : {M.refresh_ends_2(~K, ~V, ~cmp, r, _) == ST.real(~K, ~V, ~cmp, MI.refresh_ends_1(~K, ~V, ~cmp, Tuple{m1, r})) : M.TreeMap<K, V, cmp>}
      refresh_ends_2_s(~K, ~V, ~cmp, r, MI.extreme(~K, ~V, ~cmp, m1, r, False{}), extreme_g(~K, ~V, ~cmp, m1, r, False{}, g_pair_result))


def nav_equal_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +higher: Bool, +inclusive: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.nav_equal(~K, ~V, ~cmp, m, id, higher, inclusive)) == True{} : Bool}:
  match inclusive:
    case True{}:
      g_m
    case False{}:
      neighbor_g(~K, ~V, ~cmp, m, id, higher, g_m)

def nav_equal_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +higher: Bool, +inclusive: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.nav_equal(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id, higher, inclusive) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_equal(~K, ~V, ~cmp, m, id, higher, inclusive)) : M.TreeMap<K, V, cmp> & Nat}:
  match inclusive:
    case True{}:
      {==}
    case False{}:
      neighbor_s(~K, ~V, ~cmp, m, id, higher, g_m)


def first_key_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, K>, MI.first_key(~K, ~V, ~cmp, m)) == True{} : Bool}:
  key_id_g(~K, ~V, ~cmp, MI.first_id(~K, ~V, ~cmp, m), first_id_g(~K, ~V, ~cmp, m, g_m))

def first_key_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.first_key(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)) == MI.rp(~K, ~V, ~cmp, Maybe<&2, K>, MI.first_key(~K, ~V, ~cmp, m)) : M.TreeMap<K, V, cmp> & Maybe<&2, K>}:
  %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.first_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)), MI.rp(~K, ~V, ~cmp, Nat, MI.first_id(~K, ~V, ~cmp, m)), first_id_s(~K, ~V, ~cmp, m, g_m)) : {M.key_id(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, K>, MI.first_key(~K, ~V, ~cmp, m)) : M.TreeMap<K, V, cmp> & Maybe<&2, K>}
  key_id_s(~K, ~V, ~cmp, MI.first_id(~K, ~V, ~cmp, m), first_id_g(~K, ~V, ~cmp, m, g_m))


def last_key_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, K>, MI.last_key(~K, ~V, ~cmp, m)) == True{} : Bool}:
  key_id_g(~K, ~V, ~cmp, MI.last_id(~K, ~V, ~cmp, m), last_id_g(~K, ~V, ~cmp, m, g_m))

def last_key_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.last_key(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)) == MI.rp(~K, ~V, ~cmp, Maybe<&2, K>, MI.last_key(~K, ~V, ~cmp, m)) : M.TreeMap<K, V, cmp> & Maybe<&2, K>}:
  %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.last_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)), MI.rp(~K, ~V, ~cmp, Nat, MI.last_id(~K, ~V, ~cmp, m)), last_id_s(~K, ~V, ~cmp, m, g_m)) : {M.key_id(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, K>, MI.last_key(~K, ~V, ~cmp, m)) : M.TreeMap<K, V, cmp> & Maybe<&2, K>}
  key_id_s(~K, ~V, ~cmp, MI.last_id(~K, ~V, ~cmp, m), last_id_g(~K, ~V, ~cmp, m, g_m))


def view_get_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +k: K, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {MI.dgvp(K, V, Maybe<&2, V>, MI.view_get(~K, ~V, ~cmp, view, k)) == True{} : Bool}:
  match view:
    case MI.MV{+m, +lower, +upper, +descending}:
      view_get_checked_g(~K, ~V, ~cmp, m, k, lower, upper, descending, M.in_range(~K, ~V, ~cmp, k, lower, upper), g_view)

def view_get_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +k: K, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {M.view_get(~K, ~V, ~cmp, MI.rv(~K, ~V, ~cmp, view), k) == MI.rvp(~K, ~V, ~cmp, Maybe<&2, V>, MI.view_get(~K, ~V, ~cmp, view, k)) : M.View<K, V, cmp> & Maybe<&2, V>}:
  match view:
    case MI.MV{+m, +lower, +upper, +descending}:
      view_get_checked_s(~K, ~V, ~cmp, m, k, lower, upper, descending, M.in_range(~K, ~V, ~cmp, k, lower, upper), g_view)


def rotate_left_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +x: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.rotate_left(~K, ~V, ~cmp, m, x)) == True{} : Bool}:
  rotate_left_1_g(~K, ~V, ~cmp, x, MI.read(~K, ~V, ~cmp, m, x), read_g(~K, ~V, ~cmp, m, x, g_m))

def rotate_left_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +x: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.rotate_left(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), x) == ST.real(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, m, x)) : M.TreeMap<K, V, cmp>}:
  %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), x), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m, x)), read_s(~K, ~V, ~cmp, m, x, g_m)) : {M.rotate_left_1(~K, ~V, ~cmp, x, _) == ST.real(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, m, x)) : M.TreeMap<K, V, cmp>}
  rotate_left_1_s(~K, ~V, ~cmp, x, MI.read(~K, ~V, ~cmp, m, x), read_g(~K, ~V, ~cmp, m, x, g_m))


def rotate_right_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +x: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.rotate_right(~K, ~V, ~cmp, m, x)) == True{} : Bool}:
  rotate_right_1_g(~K, ~V, ~cmp, x, MI.read(~K, ~V, ~cmp, m, x), read_g(~K, ~V, ~cmp, m, x, g_m))

def rotate_right_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +x: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.rotate_right(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), x) == ST.real(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, m, x)) : M.TreeMap<K, V, cmp>}:
  %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), x), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m, x)), read_s(~K, ~V, ~cmp, m, x, g_m)) : {M.rotate_right_1(~K, ~V, ~cmp, x, _) == ST.real(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, m, x)) : M.TreeMap<K, V, cmp>}
  rotate_right_1_s(~K, ~V, ~cmp, x, MI.read(~K, ~V, ~cmp, m, x), read_g(~K, ~V, ~cmp, m, x, g_m))


def move_successor_2_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +target: Nat, +source: Nat, +source_node: M.Node<K>, pair_result: ST.Sh<K, V> & Maybe<&2, V>, +g_pair_result: {MI.dgp(K, V, Maybe<&2, V>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.move_successor_2(~K, ~V, ~cmp, target, source, source_node, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m2, +value}:
      move_successor_3_g(~K, ~V, ~cmp, source, MI.exchange(~K, ~V, ~cmp, MI.copy_key(~K, ~V, ~cmp, m2, target, source_node), target, value), exchange_g(~K, ~V, ~cmp, MI.copy_key(~K, ~V, ~cmp, m2, target, source_node), target, value, copy_key_g(~K, ~V, ~cmp, m2, target, source_node, g_pair_result)))

def move_successor_2_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +target: Nat, +source: Nat, +source_node: M.Node<K>, pair_result: ST.Sh<K, V> & Maybe<&2, V>, +g_pair_result: {MI.dgp(K, V, Maybe<&2, V>, pair_result) == True{} : Bool}) -> {M.move_successor_2(~K, ~V, ~cmp, target, source, source_node, MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, pair_result)) == MI.rp(~K, ~V, ~cmp, Nat, MI.move_successor_2(~K, ~V, ~cmp, target, source, source_node, pair_result)) : M.TreeMap<K, V, cmp> & Nat}:
  match pair_result:
    case Tuple{+m2, +value}:
      %Equal.sym(M.TreeMap<K, V, cmp>, M.copy_key(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m2), target, source_node), ST.real(~K, ~V, ~cmp, MI.copy_key(~K, ~V, ~cmp, m2, target, source_node)), copy_key_s(~K, ~V, ~cmp, m2, target, source_node, g_pair_result)) : {M.move_successor_3(~K, ~V, ~cmp, source, M.exchange(~K, ~V, ~cmp, _, target, value)) == MI.rp(~K, ~V, ~cmp, Nat, MI.move_successor_2(~K, ~V, ~cmp, target, source, source_node, Tuple{m2, value})) : M.TreeMap<K, V, cmp> & Nat}
      %Equal.sym(M.TreeMap<K, V, cmp> & Maybe<&2, V>, M.exchange(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.copy_key(~K, ~V, ~cmp, m2, target, source_node)), target, value), MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.exchange(~K, ~V, ~cmp, MI.copy_key(~K, ~V, ~cmp, m2, target, source_node), target, value)), exchange_s(~K, ~V, ~cmp, MI.copy_key(~K, ~V, ~cmp, m2, target, source_node), target, value, copy_key_g(~K, ~V, ~cmp, m2, target, source_node, g_pair_result))) : {M.move_successor_3(~K, ~V, ~cmp, source, _) == MI.rp(~K, ~V, ~cmp, Nat, MI.move_successor_2(~K, ~V, ~cmp, target, source, source_node, Tuple{m2, value})) : M.TreeMap<K, V, cmp> & Nat}
      move_successor_3_s(~K, ~V, ~cmp, source, MI.exchange(~K, ~V, ~cmp, MI.copy_key(~K, ~V, ~cmp, m2, target, source_node), target, value), exchange_g(~K, ~V, ~cmp, MI.copy_key(~K, ~V, ~cmp, m2, target, source_node), target, value, copy_key_g(~K, ~V, ~cmp, m2, target, source_node, g_pair_result)))


def refresh_ends_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.refresh_ends(~K, ~V, ~cmp, m)) == True{} : Bool}:
  refresh_ends_1_g(~K, ~V, ~cmp, MI.root_id(~K, ~V, ~cmp, m), root_id_g(~K, ~V, ~cmp, m, g_m))

def refresh_ends_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.refresh_ends(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)) == ST.real(~K, ~V, ~cmp, MI.refresh_ends(~K, ~V, ~cmp, m)) : M.TreeMap<K, V, cmp>}:
  %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.root_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)), MI.rp(~K, ~V, ~cmp, Nat, MI.root_id(~K, ~V, ~cmp, m)), root_id_s(~K, ~V, ~cmp, m, g_m)) : {M.refresh_ends_1(~K, ~V, ~cmp, _) == ST.real(~K, ~V, ~cmp, MI.refresh_ends(~K, ~V, ~cmp, m)) : M.TreeMap<K, V, cmp>}
  refresh_ends_1_s(~K, ~V, ~cmp, MI.root_id(~K, ~V, ~cmp, m), root_id_g(~K, ~V, ~cmp, m, g_m))


def nav_loop_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +fuel: Nat, +k: K, +higher: Bool, +inclusive: Bool, +id: Nat, +best: Nat, st: ST.Sh<K, V> & (M.Node<K> & Cmp), +g_st: {MI.dgp(K, V, (M.Node<K> & Cmp), st) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.nav_loop(~K, ~V, ~cmp, fuel, k, higher, inclusive, id, best, st)) == True{} : Bool}:
  match fuel st:
    case 0n Tuple{+px4, Tuple{M.Free{+px8}, LT{}}}:
      g_st
    case 0n Tuple{+px4, Tuple{M.Free{+px8}, EQ{}}}:
      g_st
    case 0n Tuple{+px4, Tuple{M.Free{+px8}, GT{}}}:
      g_st
    case 0n Tuple{+px4, Tuple{M.N{+px9, +px10, +px11, +px12, +px13}, LT{}}}:
      g_st
    case 0n Tuple{+px4, Tuple{M.N{+px9, +px10, +px11, +px12, +px13}, EQ{}}}:
      g_st
    case 0n Tuple{+px4, Tuple{M.N{+px9, +px10, +px11, +px12, +px13}, GT{}}}:
      g_st
    case 1n+ +px3 Tuple{+px14, Tuple{M.Free{+px18}, LT{}}}:
      g_st
    case 1n+ +px3 Tuple{+px14, Tuple{M.Free{+px18}, EQ{}}}:
      g_st
    case 1n+ +px3 Tuple{+px14, Tuple{M.Free{+px18}, GT{}}}:
      g_st
    case 1n+ +px3 Tuple{+px14, Tuple{M.N{+px19, +px20, +px21, +px22, +px23}, LT{}}}:
      nav_loop_g(~K, ~V, ~cmp, px3, k, higher, inclusive, px20, M.pick(Nat, higher, id, best), MI.probe(~K, ~V, ~cmp, px14, px20, k), probe_g(~K, ~V, ~cmp, px14, px20, k, g_st))
    case 1n+ +px3 Tuple{+px14, Tuple{M.N{+px19, +px20, +px21, +px22, +px23}, GT{}}}:
      nav_loop_g(~K, ~V, ~cmp, px3, k, higher, inclusive, px21, M.pick(Nat, higher, best, id), MI.probe(~K, ~V, ~cmp, px14, px21, k), probe_g(~K, ~V, ~cmp, px14, px21, k, g_st))
    case 1n+ +px3 Tuple{+px14, Tuple{M.N{+px19, +px20, +px21, +px22, +px23}, EQ{}}}:
      nav_equal_g(~K, ~V, ~cmp, px14, id, higher, inclusive, g_st)

def nav_loop_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +fuel: Nat, +k: K, +higher: Bool, +inclusive: Bool, +id: Nat, +best: Nat, st: ST.Sh<K, V> & (M.Node<K> & Cmp), +g_st: {MI.dgp(K, V, (M.Node<K> & Cmp), st) == True{} : Bool}) -> {M.nav_loop(~K, ~V, ~cmp, fuel, k, higher, inclusive, id, best, MI.rp(~K, ~V, ~cmp, (M.Node<K> & Cmp), st)) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, fuel, k, higher, inclusive, id, best, st)) : M.TreeMap<K, V, cmp> & Nat}:
  match fuel st:
    case 0n Tuple{+px4, Tuple{M.Free{+px8}, LT{}}}:
      {==}
    case 0n Tuple{+px4, Tuple{M.Free{+px8}, EQ{}}}:
      {==}
    case 0n Tuple{+px4, Tuple{M.Free{+px8}, GT{}}}:
      {==}
    case 0n Tuple{+px4, Tuple{M.N{+px9, +px10, +px11, +px12, +px13}, LT{}}}:
      {==}
    case 0n Tuple{+px4, Tuple{M.N{+px9, +px10, +px11, +px12, +px13}, EQ{}}}:
      {==}
    case 0n Tuple{+px4, Tuple{M.N{+px9, +px10, +px11, +px12, +px13}, GT{}}}:
      {==}
    case 1n+ +px3 Tuple{+px14, Tuple{M.Free{+px18}, LT{}}}:
      {==}
    case 1n+ +px3 Tuple{+px14, Tuple{M.Free{+px18}, EQ{}}}:
      {==}
    case 1n+ +px3 Tuple{+px14, Tuple{M.Free{+px18}, GT{}}}:
      {==}
    case 1n+ +px3 Tuple{+px14, Tuple{M.N{+px19, +px20, +px21, +px22, +px23}, LT{}}}:
      %Equal.sym(M.TreeMap<K, V, cmp> & (M.Node<K> & Cmp), M.probe(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, px14), px20, k), MI.rp(~K, ~V, ~cmp, (M.Node<K> & Cmp), MI.probe(~K, ~V, ~cmp, px14, px20, k)), probe_s(~K, ~V, ~cmp, px14, px20, k, g_st)) : {M.nav_loop(~K, ~V, ~cmp, px3, k, higher, inclusive, px20, M.pick(Nat, higher, id, best), _) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, 1n+ px3, k, higher, inclusive, id, best, Tuple{px14, Tuple{M.N{px19, px20, px21, px22, px23}, LT{}}})) : M.TreeMap<K, V, cmp> & Nat}
      nav_loop_s(~K, ~V, ~cmp, px3, k, higher, inclusive, px20, M.pick(Nat, higher, id, best), MI.probe(~K, ~V, ~cmp, px14, px20, k), probe_g(~K, ~V, ~cmp, px14, px20, k, g_st))
    case 1n+ +px3 Tuple{+px14, Tuple{M.N{+px19, +px20, +px21, +px22, +px23}, GT{}}}:
      %Equal.sym(M.TreeMap<K, V, cmp> & (M.Node<K> & Cmp), M.probe(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, px14), px21, k), MI.rp(~K, ~V, ~cmp, (M.Node<K> & Cmp), MI.probe(~K, ~V, ~cmp, px14, px21, k)), probe_s(~K, ~V, ~cmp, px14, px21, k, g_st)) : {M.nav_loop(~K, ~V, ~cmp, px3, k, higher, inclusive, px21, M.pick(Nat, higher, best, id), _) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, 1n+ px3, k, higher, inclusive, id, best, Tuple{px14, Tuple{M.N{px19, px20, px21, px22, px23}, GT{}}})) : M.TreeMap<K, V, cmp> & Nat}
      nav_loop_s(~K, ~V, ~cmp, px3, k, higher, inclusive, px21, M.pick(Nat, higher, best, id), MI.probe(~K, ~V, ~cmp, px14, px21, k), probe_g(~K, ~V, ~cmp, px14, px21, k, g_st))
    case 1n+ +px3 Tuple{+px14, Tuple{M.N{+px19, +px20, +px21, +px22, +px23}, EQ{}}}:
      nav_equal_s(~K, ~V, ~cmp, px14, id, higher, inclusive, g_st)


def view_contains_key_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +k: K, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {MI.dgvp(K, V, Bool, MI.view_contains_key(~K, ~V, ~cmp, view, k)) == True{} : Bool}:
  view_contains_value_g(~K, ~V, ~cmp, MI.view_get(~K, ~V, ~cmp, view, k), view_get_g(~K, ~V, ~cmp, view, k, g_view))

def view_contains_key_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +k: K, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {M.view_contains_key(~K, ~V, ~cmp, MI.rv(~K, ~V, ~cmp, view), k) == MI.rvp(~K, ~V, ~cmp, Bool, MI.view_contains_key(~K, ~V, ~cmp, view, k)) : M.View<K, V, cmp> & Bool}:
  %Equal.sym(M.View<K, V, cmp> & Maybe<&2, V>, M.view_get(~K, ~V, ~cmp, MI.rv(~K, ~V, ~cmp, view), k), MI.rvp(~K, ~V, ~cmp, Maybe<&2, V>, MI.view_get(~K, ~V, ~cmp, view, k)), view_get_s(~K, ~V, ~cmp, view, k, g_view)) : {M.view_contains_value(~K, ~V, ~cmp, _) == MI.rvp(~K, ~V, ~cmp, Bool, MI.view_contains_key(~K, ~V, ~cmp, view, k)) : M.View<K, V, cmp> & Bool}
  view_contains_value_s(~K, ~V, ~cmp, MI.view_get(~K, ~V, ~cmp, view, k), view_get_g(~K, ~V, ~cmp, view, k, g_view))


def insert_black_left_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +z: Nat, +p: Nat, +g: Nat, +triangle: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.Fix, MI.insert_black_left(~K, ~V, ~cmp, m, z, p, g, triangle)) == True{} : Bool}:
  match triangle:
    case True{}:
      rotate_right_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, m, p), z, False{}), g, True{}), g, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, m, p), z, False{}), g, True{}, set_red_g(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, m, p), z, False{}, rotate_left_g(~K, ~V, ~cmp, m, p, g_m))))
    case False{}:
      rotate_right_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), g, True{}), g, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), g, True{}, set_red_g(~K, ~V, ~cmp, m, p, False{}, g_m)))

def insert_black_left_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +z: Nat, +p: Nat, +g: Nat, +triangle: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.insert_black_left(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), z, p, g, triangle) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_black_left(~K, ~V, ~cmp, m, z, p, g, triangle)) : M.TreeMap<K, V, cmp> & M.Fix}:
  match triangle:
    case True{}:
      %Equal.sym(M.TreeMap<K, V, cmp>, M.rotate_left(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p), ST.real(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, m, p)), rotate_left_s(~K, ~V, ~cmp, m, p, g_m)) : {(M.rotate_right(~K, ~V, ~cmp, M.set_red(~K, ~V, ~cmp, M.set_red(~K, ~V, ~cmp, _, z, False{}), g, True{}), g), M.Fix{0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_black_left(~K, ~V, ~cmp, m, z, p, g, True{})) : M.TreeMap<K, V, cmp> & M.Fix}
      %Equal.sym(M.TreeMap<K, V, cmp>, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, m, p)), z, False{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, m, p), z, False{})), set_red_s(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, m, p), z, False{}, rotate_left_g(~K, ~V, ~cmp, m, p, g_m))) : {(M.rotate_right(~K, ~V, ~cmp, M.set_red(~K, ~V, ~cmp, _, g, True{}), g), M.Fix{0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_black_left(~K, ~V, ~cmp, m, z, p, g, True{})) : M.TreeMap<K, V, cmp> & M.Fix}
      %Equal.sym(M.TreeMap<K, V, cmp>, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, m, p), z, False{})), g, True{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, m, p), z, False{}), g, True{})), set_red_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, m, p), z, False{}), g, True{}, set_red_g(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, m, p), z, False{}, rotate_left_g(~K, ~V, ~cmp, m, p, g_m)))) : {(M.rotate_right(~K, ~V, ~cmp, _, g), M.Fix{0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_black_left(~K, ~V, ~cmp, m, z, p, g, True{})) : M.TreeMap<K, V, cmp> & M.Fix}
      %Equal.sym(M.TreeMap<K, V, cmp>, M.rotate_right(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, m, p), z, False{}), g, True{})), g), ST.real(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, m, p), z, False{}), g, True{}), g)), rotate_right_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, m, p), z, False{}), g, True{}), g, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, m, p), z, False{}), g, True{}, set_red_g(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, m, p), z, False{}, rotate_left_g(~K, ~V, ~cmp, m, p, g_m))))) : {(_, M.Fix{0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_black_left(~K, ~V, ~cmp, m, z, p, g, True{})) : M.TreeMap<K, V, cmp> & M.Fix}
      {==}
    case False{}:
      %Equal.sym(M.TreeMap<K, V, cmp>, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p, False{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{})), set_red_s(~K, ~V, ~cmp, m, p, False{}, g_m)) : {(M.rotate_right(~K, ~V, ~cmp, M.set_red(~K, ~V, ~cmp, _, g, True{}), g), M.Fix{0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_black_left(~K, ~V, ~cmp, m, z, p, g, False{})) : M.TreeMap<K, V, cmp> & M.Fix}
      %Equal.sym(M.TreeMap<K, V, cmp>, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{})), g, True{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), g, True{})), set_red_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), g, True{}, set_red_g(~K, ~V, ~cmp, m, p, False{}, g_m))) : {(M.rotate_right(~K, ~V, ~cmp, _, g), M.Fix{0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_black_left(~K, ~V, ~cmp, m, z, p, g, False{})) : M.TreeMap<K, V, cmp> & M.Fix}
      %Equal.sym(M.TreeMap<K, V, cmp>, M.rotate_right(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), g, True{})), g), ST.real(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), g, True{}), g)), rotate_right_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), g, True{}), g, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), g, True{}, set_red_g(~K, ~V, ~cmp, m, p, False{}, g_m)))) : {(_, M.Fix{0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_black_left(~K, ~V, ~cmp, m, z, p, g, False{})) : M.TreeMap<K, V, cmp> & M.Fix}
      {==}


def insert_black_right_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +z: Nat, +p: Nat, +g: Nat, +triangle: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.Fix, MI.insert_black_right(~K, ~V, ~cmp, m, z, p, g, triangle)) == True{} : Bool}:
  match triangle:
    case True{}:
      rotate_left_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, m, p), z, False{}), g, True{}), g, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, m, p), z, False{}), g, True{}, set_red_g(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, m, p), z, False{}, rotate_right_g(~K, ~V, ~cmp, m, p, g_m))))
    case False{}:
      rotate_left_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), g, True{}), g, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), g, True{}, set_red_g(~K, ~V, ~cmp, m, p, False{}, g_m)))

def insert_black_right_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +z: Nat, +p: Nat, +g: Nat, +triangle: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.insert_black_right(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), z, p, g, triangle) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_black_right(~K, ~V, ~cmp, m, z, p, g, triangle)) : M.TreeMap<K, V, cmp> & M.Fix}:
  match triangle:
    case True{}:
      %Equal.sym(M.TreeMap<K, V, cmp>, M.rotate_right(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p), ST.real(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, m, p)), rotate_right_s(~K, ~V, ~cmp, m, p, g_m)) : {(M.rotate_left(~K, ~V, ~cmp, M.set_red(~K, ~V, ~cmp, M.set_red(~K, ~V, ~cmp, _, z, False{}), g, True{}), g), M.Fix{0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_black_right(~K, ~V, ~cmp, m, z, p, g, True{})) : M.TreeMap<K, V, cmp> & M.Fix}
      %Equal.sym(M.TreeMap<K, V, cmp>, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, m, p)), z, False{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, m, p), z, False{})), set_red_s(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, m, p), z, False{}, rotate_right_g(~K, ~V, ~cmp, m, p, g_m))) : {(M.rotate_left(~K, ~V, ~cmp, M.set_red(~K, ~V, ~cmp, _, g, True{}), g), M.Fix{0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_black_right(~K, ~V, ~cmp, m, z, p, g, True{})) : M.TreeMap<K, V, cmp> & M.Fix}
      %Equal.sym(M.TreeMap<K, V, cmp>, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, m, p), z, False{})), g, True{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, m, p), z, False{}), g, True{})), set_red_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, m, p), z, False{}), g, True{}, set_red_g(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, m, p), z, False{}, rotate_right_g(~K, ~V, ~cmp, m, p, g_m)))) : {(M.rotate_left(~K, ~V, ~cmp, _, g), M.Fix{0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_black_right(~K, ~V, ~cmp, m, z, p, g, True{})) : M.TreeMap<K, V, cmp> & M.Fix}
      %Equal.sym(M.TreeMap<K, V, cmp>, M.rotate_left(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, m, p), z, False{}), g, True{})), g), ST.real(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, m, p), z, False{}), g, True{}), g)), rotate_left_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, m, p), z, False{}), g, True{}), g, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, m, p), z, False{}), g, True{}, set_red_g(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, m, p), z, False{}, rotate_right_g(~K, ~V, ~cmp, m, p, g_m))))) : {(_, M.Fix{0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_black_right(~K, ~V, ~cmp, m, z, p, g, True{})) : M.TreeMap<K, V, cmp> & M.Fix}
      {==}
    case False{}:
      %Equal.sym(M.TreeMap<K, V, cmp>, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p, False{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{})), set_red_s(~K, ~V, ~cmp, m, p, False{}, g_m)) : {(M.rotate_left(~K, ~V, ~cmp, M.set_red(~K, ~V, ~cmp, _, g, True{}), g), M.Fix{0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_black_right(~K, ~V, ~cmp, m, z, p, g, False{})) : M.TreeMap<K, V, cmp> & M.Fix}
      %Equal.sym(M.TreeMap<K, V, cmp>, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{})), g, True{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), g, True{})), set_red_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), g, True{}, set_red_g(~K, ~V, ~cmp, m, p, False{}, g_m))) : {(M.rotate_left(~K, ~V, ~cmp, _, g), M.Fix{0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_black_right(~K, ~V, ~cmp, m, z, p, g, False{})) : M.TreeMap<K, V, cmp> & M.Fix}
      %Equal.sym(M.TreeMap<K, V, cmp>, M.rotate_left(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), g, True{})), g), ST.real(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), g, True{}), g)), rotate_left_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), g, True{}), g, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), g, True{}, set_red_g(~K, ~V, ~cmp, m, p, False{}, g_m)))) : {(_, M.Fix{0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_black_right(~K, ~V, ~cmp, m, z, p, g, False{})) : M.TreeMap<K, V, cmp> & M.Fix}
      {==}


def move_successor_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +target: Nat, +source: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.move_successor_1(~K, ~V, ~cmp, target, source, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m1, +source_node}:
      move_successor_2_g(~K, ~V, ~cmp, target, source, source_node, MI.exchange(~K, ~V, ~cmp, m1, source, None{}), exchange_g(~K, ~V, ~cmp, m1, source, None{}, g_pair_result))

def move_successor_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +target: Nat, +source: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.move_successor_1(~K, ~V, ~cmp, target, source, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, Nat, MI.move_successor_1(~K, ~V, ~cmp, target, source, pair_result)) : M.TreeMap<K, V, cmp> & Nat}:
  match pair_result:
    case Tuple{+m1, +source_node}:
      %Equal.sym(M.TreeMap<K, V, cmp> & Maybe<&2, V>, M.exchange(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m1), source, None{}), MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.exchange(~K, ~V, ~cmp, m1, source, None{})), exchange_s(~K, ~V, ~cmp, m1, source, None{}, g_pair_result)) : {M.move_successor_2(~K, ~V, ~cmp, target, source, source_node, _) == MI.rp(~K, ~V, ~cmp, Nat, MI.move_successor_1(~K, ~V, ~cmp, target, source, Tuple{m1, source_node})) : M.TreeMap<K, V, cmp> & Nat}
      move_successor_2_s(~K, ~V, ~cmp, target, source, source_node, MI.exchange(~K, ~V, ~cmp, m1, source, None{}), exchange_g(~K, ~V, ~cmp, m1, source, None{}, g_pair_result))


def delete_borrow_left_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +w: Nat, +pn: M.Node<K>, +wn: M.Node<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_borrow_left(~K, ~V, ~cmp, m, p, w, pn, wn)) == True{} : Bool}:
  rotate_left_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}), M.node_right(~K, wn), False{}), p, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}), M.node_right(~K, wn), False{}, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}, set_red_g(~K, ~V, ~cmp, m, w, M.node_red(~K, pn), g_m))))

def delete_borrow_left_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +w: Nat, +pn: M.Node<K>, +wn: M.Node<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.delete_borrow_left(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p, w, pn, wn) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_borrow_left(~K, ~V, ~cmp, m, p, w, pn, wn)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
  %Equal.sym(M.TreeMap<K, V, cmp>, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), w, M.node_red(~K, pn)), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn))), set_red_s(~K, ~V, ~cmp, m, w, M.node_red(~K, pn), g_m)) : {(M.rotate_left(~K, ~V, ~cmp, M.set_red(~K, ~V, ~cmp, M.set_red(~K, ~V, ~cmp, _, p, False{}), M.node_right(~K, wn), False{}), p), M.DF{0n, 0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_borrow_left(~K, ~V, ~cmp, m, p, w, pn, wn)) : M.TreeMap<K, V, cmp> & M.DeleteFix}
  %Equal.sym(M.TreeMap<K, V, cmp>, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn))), p, False{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{})), set_red_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}, set_red_g(~K, ~V, ~cmp, m, w, M.node_red(~K, pn), g_m))) : {(M.rotate_left(~K, ~V, ~cmp, M.set_red(~K, ~V, ~cmp, _, M.node_right(~K, wn), False{}), p), M.DF{0n, 0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_borrow_left(~K, ~V, ~cmp, m, p, w, pn, wn)) : M.TreeMap<K, V, cmp> & M.DeleteFix}
  %Equal.sym(M.TreeMap<K, V, cmp>, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{})), M.node_right(~K, wn), False{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}), M.node_right(~K, wn), False{})), set_red_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}), M.node_right(~K, wn), False{}, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}, set_red_g(~K, ~V, ~cmp, m, w, M.node_red(~K, pn), g_m)))) : {(M.rotate_left(~K, ~V, ~cmp, _, p), M.DF{0n, 0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_borrow_left(~K, ~V, ~cmp, m, p, w, pn, wn)) : M.TreeMap<K, V, cmp> & M.DeleteFix}
  %Equal.sym(M.TreeMap<K, V, cmp>, M.rotate_left(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}), M.node_right(~K, wn), False{})), p), ST.real(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}), M.node_right(~K, wn), False{}), p)), rotate_left_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}), M.node_right(~K, wn), False{}), p, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}), M.node_right(~K, wn), False{}, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}, set_red_g(~K, ~V, ~cmp, m, w, M.node_red(~K, pn), g_m))))) : {(_, M.DF{0n, 0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_borrow_left(~K, ~V, ~cmp, m, p, w, pn, wn)) : M.TreeMap<K, V, cmp> & M.DeleteFix}
  {==}


def delete_borrow_right_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +w: Nat, +pn: M.Node<K>, +wn: M.Node<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_borrow_right(~K, ~V, ~cmp, m, p, w, pn, wn)) == True{} : Bool}:
  rotate_right_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}), M.node_left(~K, wn), False{}), p, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}), M.node_left(~K, wn), False{}, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}, set_red_g(~K, ~V, ~cmp, m, w, M.node_red(~K, pn), g_m))))

def delete_borrow_right_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +w: Nat, +pn: M.Node<K>, +wn: M.Node<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.delete_borrow_right(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p, w, pn, wn) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_borrow_right(~K, ~V, ~cmp, m, p, w, pn, wn)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
  %Equal.sym(M.TreeMap<K, V, cmp>, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), w, M.node_red(~K, pn)), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn))), set_red_s(~K, ~V, ~cmp, m, w, M.node_red(~K, pn), g_m)) : {(M.rotate_right(~K, ~V, ~cmp, M.set_red(~K, ~V, ~cmp, M.set_red(~K, ~V, ~cmp, _, p, False{}), M.node_left(~K, wn), False{}), p), M.DF{0n, 0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_borrow_right(~K, ~V, ~cmp, m, p, w, pn, wn)) : M.TreeMap<K, V, cmp> & M.DeleteFix}
  %Equal.sym(M.TreeMap<K, V, cmp>, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn))), p, False{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{})), set_red_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}, set_red_g(~K, ~V, ~cmp, m, w, M.node_red(~K, pn), g_m))) : {(M.rotate_right(~K, ~V, ~cmp, M.set_red(~K, ~V, ~cmp, _, M.node_left(~K, wn), False{}), p), M.DF{0n, 0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_borrow_right(~K, ~V, ~cmp, m, p, w, pn, wn)) : M.TreeMap<K, V, cmp> & M.DeleteFix}
  %Equal.sym(M.TreeMap<K, V, cmp>, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{})), M.node_left(~K, wn), False{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}), M.node_left(~K, wn), False{})), set_red_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}), M.node_left(~K, wn), False{}, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}, set_red_g(~K, ~V, ~cmp, m, w, M.node_red(~K, pn), g_m)))) : {(M.rotate_right(~K, ~V, ~cmp, _, p), M.DF{0n, 0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_borrow_right(~K, ~V, ~cmp, m, p, w, pn, wn)) : M.TreeMap<K, V, cmp> & M.DeleteFix}
  %Equal.sym(M.TreeMap<K, V, cmp>, M.rotate_right(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}), M.node_left(~K, wn), False{})), p), ST.real(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}), M.node_left(~K, wn), False{}), p)), rotate_right_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}), M.node_left(~K, wn), False{}), p, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}), M.node_left(~K, wn), False{}, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, M.node_red(~K, pn)), p, False{}, set_red_g(~K, ~V, ~cmp, m, w, M.node_red(~K, pn), g_m))))) : {(_, M.DF{0n, 0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_borrow_right(~K, ~V, ~cmp, m, p, w, pn, wn)) : M.TreeMap<K, V, cmp> & M.DeleteFix}
  {==}


# ---- navigate: the fast descent keeps the candidate, the mirror's loop probes ----


# the order of a live node decides: descend (the rest by ih) or finish at the equal node
def nq_o(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)) == True{} : Bool}, +g: {MI.dg(K, V, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}) == True{} : Bool}, +k: K, +h: Bool, +inc: Bool, +f: Nat, +i: Nat, +b: Nat, +c: Bool, +lf: Nat, +rt: Nat, +q: Nat, +key: K, +hy: {ST.nth_or(M.Node<K>, nl, i, M.Free{0n}) == M.N{c, lf, rt, q, key} : M.Node<K>}, ih: @+id2: Nat -> @+b2: Nat -> {M.nav_end(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), h, inc, M.nav_fast(~K, ~V, ~cmp, f, k, h, b2, M.search_probe(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), id2, k))) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, f, k, h, inc, id2, b2, MI.probe(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, id2, k))) : M.TreeMap<K, V, cmp> & Nat}, +c0: Cmp) -> {M.nav_end(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), h, inc, M.nav_fast(~K, ~V, ~cmp, 1n+f, k, h, b, (ST.nodes(~K, l, d, nl), (1n+i, Some{c0})))) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, 1n+f, k, h, inc, 1n+i, b, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, (M.N{c, lf, rt, q, key}, c0)))) : M.TreeMap<K, V, cmp> & Nat}:
  match c0:
    case LT{}:
      %Equal.sym(M.NodeStore<K> & Nat, M.side_at(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), True{}, i), (ST.nodes(~K, l, d, nl), M.pick(Nat, True{}, M.nleft(~K, ST.nth_or(M.Node<K>, nl, i, M.Free{0n})), M.nright(~K, ST.nth_or(M.Node<K>, nl, i, M.Free{0n})))), side_ok(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, True{}, i)) : {M.nav_end(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), h, inc, M.nav_fast(~K, ~V, ~cmp, f, k, h, M.pick(Nat, h, 1n+i, b), M.search_down2(~K, ~V, ~cmp, k, _))) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, 1n+f, k, h, inc, 1n+i, b, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, (M.N{c, lf, rt, q, key}, LT{})))) : M.TreeMap<K, V, cmp> & Nat}
      %Equal.sym(M.Node<K>, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}), M.N{c, lf, rt, q, key}, hy) : {M.nav_end(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), h, inc, M.nav_fast(~K, ~V, ~cmp, f, k, h, M.pick(Nat, h, 1n+i, b), M.search_probe(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), M.nleft(~K, _), k))) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, 1n+f, k, h, inc, 1n+i, b, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, (M.N{c, lf, rt, q, key}, LT{})))) : M.TreeMap<K, V, cmp> & Nat}
      ih(lf, M.pick(Nat, h, 1n+i, b))
    case GT{}:
      %Equal.sym(M.NodeStore<K> & Nat, M.side_at(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), False{}, i), (ST.nodes(~K, l, d, nl), M.pick(Nat, False{}, M.nleft(~K, ST.nth_or(M.Node<K>, nl, i, M.Free{0n})), M.nright(~K, ST.nth_or(M.Node<K>, nl, i, M.Free{0n})))), side_ok(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, False{}, i)) : {M.nav_end(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), h, inc, M.nav_fast(~K, ~V, ~cmp, f, k, h, M.pick(Nat, h, b, 1n+i), M.search_down2(~K, ~V, ~cmp, k, _))) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, 1n+f, k, h, inc, 1n+i, b, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, (M.N{c, lf, rt, q, key}, GT{})))) : M.TreeMap<K, V, cmp> & Nat}
      %Equal.sym(M.Node<K>, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}), M.N{c, lf, rt, q, key}, hy) : {M.nav_end(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), h, inc, M.nav_fast(~K, ~V, ~cmp, f, k, h, M.pick(Nat, h, b, 1n+i), M.search_probe(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), M.nright(~K, _), k))) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, 1n+f, k, h, inc, 1n+i, b, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, (M.N{c, lf, rt, q, key}, GT{})))) : M.TreeMap<K, V, cmp> & Nat}
      ih(rt, M.pick(Nat, h, b, 1n+i))
    case EQ{}:
      nav_equal_s(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, 1n+i, h, inc, g)

def nq_c(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)) == True{} : Bool}, +g: {MI.dg(K, V, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}) == True{} : Bool}, +k: K, +h: Bool, +inc: Bool, +f: Nat, +i: Nat, +b: Nat, +c: Bool, +lf: Nat, +rt: Nat, +q: Nat, +key: K, +hy: {ST.nth_or(M.Node<K>, nl, i, M.Free{0n}) == M.N{c, lf, rt, q, key} : M.Node<K>}, ih: @+id2: Nat -> @+b2: Nat -> {M.nav_end(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), h, inc, M.nav_fast(~K, ~V, ~cmp, f, k, h, b2, M.search_probe(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), id2, k))) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, f, k, h, inc, id2, b2, MI.probe(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, id2, k))) : M.TreeMap<K, V, cmp> & Nat}, +c0: Cmp, +hco: {cmp(k, key) == c0 : Cmp}) -> {M.nav_end(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), h, inc, M.nav_fast(~K, ~V, ~cmp, 1n+f, k, h, b, (ST.nodes(~K, l, d, nl), (1n+i, Some{cmp(k, key)})))) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, 1n+f, k, h, inc, 1n+i, b, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, (M.N{c, lf, rt, q, key}, cmp(k, key))))) : M.TreeMap<K, V, cmp> & Nat}:
  %Equal.sym(Cmp, cmp(k, key), c0, hco) : {M.nav_end(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), h, inc, M.nav_fast(~K, ~V, ~cmp, 1n+f, k, h, b, (ST.nodes(~K, l, d, nl), (1n+i, Some{_})))) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, 1n+f, k, h, inc, 1n+i, b, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, (M.N{c, lf, rt, q, key}, _)))) : M.TreeMap<K, V, cmp> & Nat}
  nq_o(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, hl, hd, hc, hp, g, k, h, inc, f, i, b, c, lf, rt, q, key, hy, ih, c0)

def nq_y(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)) == True{} : Bool}, +g: {MI.dg(K, V, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}) == True{} : Bool}, +k: K, +h: Bool, +inc: Bool, +f: Nat, +i: Nat, +b: Nat, +y: M.Node<K>, +hy: {ST.nth_or(M.Node<K>, nl, i, M.Free{0n}) == y : M.Node<K>}, ih: @+id2: Nat -> @+b2: Nat -> {M.nav_end(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), h, inc, M.nav_fast(~K, ~V, ~cmp, f, k, h, b2, M.search_probe(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), id2, k))) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, f, k, h, inc, id2, b2, MI.probe(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, id2, k))) : M.TreeMap<K, V, cmp> & Nat}) -> {M.nav_end(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), h, inc, M.nav_fast(~K, ~V, ~cmp, 1n+f, k, h, b, M.search_key(~K, ~V, ~cmp, 1n+i, k, (ST.nodes(~K, l, d, nl), M.nkey(~K, y))))) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, 1n+f, k, h, inc, 1n+i, b, MI.probe_node(~K, ~V, ~cmp, 1n+i, k, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, y)))) : M.TreeMap<K, V, cmp> & Nat}:
  match y:
    case M.Free{z}:
      {==}
    case M.N{+c, +lf, +rt, +q, +key}:
      nq_c(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, hl, hd, hc, hp, g, k, h, inc, f, i, b, c, lf, rt, q, key, hy, ih, cmp(k, key), {==})

def n0_o(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)) == True{} : Bool}, +g: {MI.dg(K, V, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}) == True{} : Bool}, +k: K, +h: Bool, +inc: Bool, +i: Nat, +b: Nat, +c: Bool, +lf: Nat, +rt: Nat, +q: Nat, +key: K, +c0: Cmp) -> {M.nav_end(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), h, inc, M.nav_fast(~K, ~V, ~cmp, 0n, k, h, b, (ST.nodes(~K, l, d, nl), (1n+i, Some{c0})))) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, 0n, k, h, inc, 1n+i, b, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, (M.N{c, lf, rt, q, key}, c0)))) : M.TreeMap<K, V, cmp> & Nat}:
  match c0:
    case LT{}:
      {==}
    case GT{}:
      {==}
    case EQ{}:
      {==}

def n0_c(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)) == True{} : Bool}, +g: {MI.dg(K, V, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}) == True{} : Bool}, +k: K, +h: Bool, +inc: Bool, +i: Nat, +b: Nat, +c: Bool, +lf: Nat, +rt: Nat, +q: Nat, +key: K, +c0: Cmp, +hco: {cmp(k, key) == c0 : Cmp}) -> {M.nav_end(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), h, inc, M.nav_fast(~K, ~V, ~cmp, 0n, k, h, b, (ST.nodes(~K, l, d, nl), (1n+i, Some{cmp(k, key)})))) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, 0n, k, h, inc, 1n+i, b, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, (M.N{c, lf, rt, q, key}, cmp(k, key))))) : M.TreeMap<K, V, cmp> & Nat}:
  %Equal.sym(Cmp, cmp(k, key), c0, hco) : {M.nav_end(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), h, inc, M.nav_fast(~K, ~V, ~cmp, 0n, k, h, b, (ST.nodes(~K, l, d, nl), (1n+i, Some{_})))) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, 0n, k, h, inc, 1n+i, b, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, (M.N{c, lf, rt, q, key}, _)))) : M.TreeMap<K, V, cmp> & Nat}
  n0_o(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, hl, hd, hc, hp, g, k, h, inc, i, b, c, lf, rt, q, key, c0)

def n0_y(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)) == True{} : Bool}, +g: {MI.dg(K, V, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}) == True{} : Bool}, +k: K, +h: Bool, +inc: Bool, +i: Nat, +b: Nat, +y: M.Node<K>) -> {M.nav_end(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), h, inc, M.nav_fast(~K, ~V, ~cmp, 0n, k, h, b, M.search_key(~K, ~V, ~cmp, 1n+i, k, (ST.nodes(~K, l, d, nl), M.nkey(~K, y))))) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, 0n, k, h, inc, 1n+i, b, MI.probe_node(~K, ~V, ~cmp, 1n+i, k, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, y)))) : M.TreeMap<K, V, cmp> & Nat}:
  match y:
    case M.Free{z}:
      {==}
    case M.N{+c, +lf, +rt, +q, +key}:
      n0_c(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, hl, hd, hc, hp, g, k, h, inc, i, b, c, lf, rt, q, key, cmp(k, key), {==})

# the fast descent, ended in the map, is the mirror's loop
def nq(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)) == True{} : Bool}, +g: {MI.dg(K, V, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}) == True{} : Bool}, +k: K, +h: Bool, +inc: Bool, +fuel: Nat, +id: Nat, +b: Nat) -> {M.nav_end(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), h, inc, M.nav_fast(~K, ~V, ~cmp, fuel, k, h, b, M.search_probe(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), id, k))) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, fuel, k, h, inc, id, b, MI.probe(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, id, k))) : M.TreeMap<K, V, cmp> & Nat}:
  match fuel id:
    case 0n 0n:
      {==}
    case 0n 1n+ +i:
      %Equal.sym(M.NodeStore<K> & Maybe<&2, K>, M.ns_key_at(~K, ST.nodes(~K, l, d, nl), i), (ST.nodes(~K, l, d, nl), M.nkey(~K, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}))), NSL.key_at_ok(~K, l, d, nl, hl, hd, hc, i)) : {M.nav_end(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), h, inc, M.nav_fast(~K, ~V, ~cmp, 0n, k, h, b, M.search_key(~K, ~V, ~cmp, 1n+i, k, _))) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, 0n, k, h, inc, 1n+i, b, MI.probe_node(~K, ~V, ~cmp, 1n+i, k, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}))))) : M.TreeMap<K, V, cmp> & Nat}
      n0_y(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, hl, hd, hc, hp, g, k, h, inc, i, b, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}))
    case 1n+f 0n:
      {==}
    case 1n+ +f 1n+ +i:
      %Equal.sym(M.NodeStore<K> & Maybe<&2, K>, M.ns_key_at(~K, ST.nodes(~K, l, d, nl), i), (ST.nodes(~K, l, d, nl), M.nkey(~K, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}))), NSL.key_at_ok(~K, l, d, nl, hl, hd, hc, i)) : {M.nav_end(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), h, inc, M.nav_fast(~K, ~V, ~cmp, 1n+f, k, h, b, M.search_key(~K, ~V, ~cmp, 1n+i, k, _))) == MI.rp(~K, ~V, ~cmp, Nat, MI.nav_loop(~K, ~V, ~cmp, 1n+f, k, h, inc, 1n+i, b, MI.probe_node(~K, ~V, ~cmp, 1n+i, k, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}))))) : M.TreeMap<K, V, cmp> & Nat}
      nq_y(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, hl, hd, hc, hp, g, k, h, inc, f, i, b, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}), {==}, id2 => b2 => nq(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, hl, hd, hc, hp, g, k, h, inc, f, id2, b2))

def navigate_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +higher: Bool, +inclusive: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.navigate(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k, higher, inclusive) == MI.rp(~K, ~V, ~cmp, Nat, MI.navigate(~K, ~V, ~cmp, m, k, higher, inclusive)) : M.TreeMap<K, V, cmp> & Nat}:
  match m:
    case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl}:
      nq(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, L.and_left(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), g_m, k, higher, inclusive, 1n+n, root, 0n)

def navigate_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +higher: Bool, +inclusive: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.navigate(~K, ~V, ~cmp, m, k, higher, inclusive)) == True{} : Bool}:
  match m:
    case ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}:
      nav_loop_g(~K, ~V, ~cmp, 1n+n, k, higher, inclusive, root, 0n, MI.probe(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, root, k), probe_g(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, root, k, g_m))

def insert_uncle_left_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +z: Nat, +p: Nat, +g: Nat, +u: Nat, +triangle: Bool, +uncle: M.Node<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.Fix, MI.insert_uncle_left(~K, ~V, ~cmp, m, z, p, g, u, triangle, uncle)) == True{} : Bool}:
  match uncle:
    case M.N{True{}, +px4, +px5, +px6, +px7}:
      set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), u, False{}), g, True{}, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), u, False{}, set_red_g(~K, ~V, ~cmp, m, p, False{}, g_m)))
    case M.Free{+px2}:
      insert_black_left_g(~K, ~V, ~cmp, m, z, p, g, triangle, g_m)
    case M.N{False{}, +px4, +px5, +px6, +px7}:
      insert_black_left_g(~K, ~V, ~cmp, m, z, p, g, triangle, g_m)

def insert_uncle_left_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +z: Nat, +p: Nat, +g: Nat, +u: Nat, +triangle: Bool, +uncle: M.Node<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.insert_uncle_left(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), z, p, g, u, triangle, uncle) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_uncle_left(~K, ~V, ~cmp, m, z, p, g, u, triangle, uncle)) : M.TreeMap<K, V, cmp> & M.Fix}:
  match uncle:
    case M.N{True{}, +px4, +px5, +px6, +px7}:
      %Equal.sym(M.TreeMap<K, V, cmp>, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p, False{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{})), set_red_s(~K, ~V, ~cmp, m, p, False{}, g_m)) : {(M.set_red(~K, ~V, ~cmp, M.set_red(~K, ~V, ~cmp, _, u, False{}), g, True{}), M.Fix{g, True{}}) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_uncle_left(~K, ~V, ~cmp, m, z, p, g, u, triangle, M.N{True{}, px4, px5, px6, px7})) : M.TreeMap<K, V, cmp> & M.Fix}
      %Equal.sym(M.TreeMap<K, V, cmp>, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{})), u, False{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), u, False{})), set_red_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), u, False{}, set_red_g(~K, ~V, ~cmp, m, p, False{}, g_m))) : {(M.set_red(~K, ~V, ~cmp, _, g, True{}), M.Fix{g, True{}}) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_uncle_left(~K, ~V, ~cmp, m, z, p, g, u, triangle, M.N{True{}, px4, px5, px6, px7})) : M.TreeMap<K, V, cmp> & M.Fix}
      %Equal.sym(M.TreeMap<K, V, cmp>, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), u, False{})), g, True{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), u, False{}), g, True{})), set_red_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), u, False{}), g, True{}, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), u, False{}, set_red_g(~K, ~V, ~cmp, m, p, False{}, g_m)))) : {(_, M.Fix{g, True{}}) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_uncle_left(~K, ~V, ~cmp, m, z, p, g, u, triangle, M.N{True{}, px4, px5, px6, px7})) : M.TreeMap<K, V, cmp> & M.Fix}
      {==}
    case M.Free{+px2}:
      insert_black_left_s(~K, ~V, ~cmp, m, z, p, g, triangle, g_m)
    case M.N{False{}, +px4, +px5, +px6, +px7}:
      insert_black_left_s(~K, ~V, ~cmp, m, z, p, g, triangle, g_m)


def insert_uncle_right_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +z: Nat, +p: Nat, +g: Nat, +u: Nat, +triangle: Bool, +uncle: M.Node<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.Fix, MI.insert_uncle_right(~K, ~V, ~cmp, m, z, p, g, u, triangle, uncle)) == True{} : Bool}:
  match uncle:
    case M.N{True{}, +px4, +px5, +px6, +px7}:
      set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), u, False{}), g, True{}, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), u, False{}, set_red_g(~K, ~V, ~cmp, m, p, False{}, g_m)))
    case M.Free{+px2}:
      insert_black_right_g(~K, ~V, ~cmp, m, z, p, g, triangle, g_m)
    case M.N{False{}, +px4, +px5, +px6, +px7}:
      insert_black_right_g(~K, ~V, ~cmp, m, z, p, g, triangle, g_m)

def insert_uncle_right_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +z: Nat, +p: Nat, +g: Nat, +u: Nat, +triangle: Bool, +uncle: M.Node<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.insert_uncle_right(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), z, p, g, u, triangle, uncle) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_uncle_right(~K, ~V, ~cmp, m, z, p, g, u, triangle, uncle)) : M.TreeMap<K, V, cmp> & M.Fix}:
  match uncle:
    case M.N{True{}, +px4, +px5, +px6, +px7}:
      %Equal.sym(M.TreeMap<K, V, cmp>, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p, False{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{})), set_red_s(~K, ~V, ~cmp, m, p, False{}, g_m)) : {(M.set_red(~K, ~V, ~cmp, M.set_red(~K, ~V, ~cmp, _, u, False{}), g, True{}), M.Fix{g, True{}}) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_uncle_right(~K, ~V, ~cmp, m, z, p, g, u, triangle, M.N{True{}, px4, px5, px6, px7})) : M.TreeMap<K, V, cmp> & M.Fix}
      %Equal.sym(M.TreeMap<K, V, cmp>, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{})), u, False{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), u, False{})), set_red_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), u, False{}, set_red_g(~K, ~V, ~cmp, m, p, False{}, g_m))) : {(M.set_red(~K, ~V, ~cmp, _, g, True{}), M.Fix{g, True{}}) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_uncle_right(~K, ~V, ~cmp, m, z, p, g, u, triangle, M.N{True{}, px4, px5, px6, px7})) : M.TreeMap<K, V, cmp> & M.Fix}
      %Equal.sym(M.TreeMap<K, V, cmp>, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), u, False{})), g, True{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), u, False{}), g, True{})), set_red_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), u, False{}), g, True{}, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, p, False{}), u, False{}, set_red_g(~K, ~V, ~cmp, m, p, False{}, g_m)))) : {(_, M.Fix{g, True{}}) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_uncle_right(~K, ~V, ~cmp, m, z, p, g, u, triangle, M.N{True{}, px4, px5, px6, px7})) : M.TreeMap<K, V, cmp> & M.Fix}
      {==}
    case M.Free{+px2}:
      insert_black_right_s(~K, ~V, ~cmp, m, z, p, g, triangle, g_m)
    case M.N{False{}, +px4, +px5, +px6, +px7}:
      insert_black_right_s(~K, ~V, ~cmp, m, z, p, g, triangle, g_m)


def move_successor_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +target: Nat, +source: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.move_successor(~K, ~V, ~cmp, m, target, source)) == True{} : Bool}:
  move_successor_1_g(~K, ~V, ~cmp, target, source, MI.read(~K, ~V, ~cmp, m, source), read_g(~K, ~V, ~cmp, m, source, g_m))

def move_successor_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +target: Nat, +source: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.move_successor(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), target, source) == MI.rp(~K, ~V, ~cmp, Nat, MI.move_successor(~K, ~V, ~cmp, m, target, source)) : M.TreeMap<K, V, cmp> & Nat}:
  %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), source), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m, source)), read_s(~K, ~V, ~cmp, m, source, g_m)) : {M.move_successor_1(~K, ~V, ~cmp, target, source, _) == MI.rp(~K, ~V, ~cmp, Nat, MI.move_successor(~K, ~V, ~cmp, m, target, source)) : M.TreeMap<K, V, cmp> & Nat}
  move_successor_1_s(~K, ~V, ~cmp, target, source, MI.read(~K, ~V, ~cmp, m, source), read_g(~K, ~V, ~cmp, m, source, g_m))


def delete_borrow_read_left_2_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +pn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_borrow_read_left_2(~K, ~V, ~cmp, p, pn, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m2, +wn}:
      delete_borrow_left_g(~K, ~V, ~cmp, m2, p, M.node_right(~K, pn), pn, wn, g_pair_result)

def delete_borrow_read_left_2_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +pn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.delete_borrow_read_left_2(~K, ~V, ~cmp, p, pn, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_borrow_read_left_2(~K, ~V, ~cmp, p, pn, pair_result)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
  match pair_result:
    case Tuple{+m2, +wn}:
      delete_borrow_left_s(~K, ~V, ~cmp, m2, p, M.node_right(~K, pn), pn, wn, g_pair_result)


def delete_borrow_read_right_2_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +pn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_borrow_read_right_2(~K, ~V, ~cmp, p, pn, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m2, +wn}:
      delete_borrow_right_g(~K, ~V, ~cmp, m2, p, M.node_left(~K, pn), pn, wn, g_pair_result)

def delete_borrow_read_right_2_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +pn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.delete_borrow_read_right_2(~K, ~V, ~cmp, p, pn, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_borrow_read_right_2(~K, ~V, ~cmp, p, pn, pair_result)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
  match pair_result:
    case Tuple{+m2, +wn}:
      delete_borrow_right_s(~K, ~V, ~cmp, m2, p, M.node_left(~K, pn), pn, wn, g_pair_result)


def lower_key_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, K>, MI.lower_key(~K, ~V, ~cmp, m, k)) == True{} : Bool}:
  key_id_g(~K, ~V, ~cmp, MI.navigate(~K, ~V, ~cmp, m, k, False{}, False{}), navigate_g(~K, ~V, ~cmp, m, k, False{}, False{}, g_m))

def lower_key_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.lower_key(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k) == MI.rp(~K, ~V, ~cmp, Maybe<&2, K>, MI.lower_key(~K, ~V, ~cmp, m, k)) : M.TreeMap<K, V, cmp> & Maybe<&2, K>}:
  %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.navigate(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k, False{}, False{}), MI.rp(~K, ~V, ~cmp, Nat, MI.navigate(~K, ~V, ~cmp, m, k, False{}, False{})), navigate_s(~K, ~V, ~cmp, m, k, False{}, False{}, g_m)) : {M.key_id(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, K>, MI.lower_key(~K, ~V, ~cmp, m, k)) : M.TreeMap<K, V, cmp> & Maybe<&2, K>}
  key_id_s(~K, ~V, ~cmp, MI.navigate(~K, ~V, ~cmp, m, k, False{}, False{}), navigate_g(~K, ~V, ~cmp, m, k, False{}, False{}, g_m))


def floor_key_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, K>, MI.floor_key(~K, ~V, ~cmp, m, k)) == True{} : Bool}:
  key_id_g(~K, ~V, ~cmp, MI.navigate(~K, ~V, ~cmp, m, k, False{}, True{}), navigate_g(~K, ~V, ~cmp, m, k, False{}, True{}, g_m))

def floor_key_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.floor_key(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k) == MI.rp(~K, ~V, ~cmp, Maybe<&2, K>, MI.floor_key(~K, ~V, ~cmp, m, k)) : M.TreeMap<K, V, cmp> & Maybe<&2, K>}:
  %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.navigate(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k, False{}, True{}), MI.rp(~K, ~V, ~cmp, Nat, MI.navigate(~K, ~V, ~cmp, m, k, False{}, True{})), navigate_s(~K, ~V, ~cmp, m, k, False{}, True{}, g_m)) : {M.key_id(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, K>, MI.floor_key(~K, ~V, ~cmp, m, k)) : M.TreeMap<K, V, cmp> & Maybe<&2, K>}
  key_id_s(~K, ~V, ~cmp, MI.navigate(~K, ~V, ~cmp, m, k, False{}, True{}), navigate_g(~K, ~V, ~cmp, m, k, False{}, True{}, g_m))


def ceiling_key_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, K>, MI.ceiling_key(~K, ~V, ~cmp, m, k)) == True{} : Bool}:
  key_id_g(~K, ~V, ~cmp, MI.navigate(~K, ~V, ~cmp, m, k, True{}, True{}), navigate_g(~K, ~V, ~cmp, m, k, True{}, True{}, g_m))

def ceiling_key_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.ceiling_key(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k) == MI.rp(~K, ~V, ~cmp, Maybe<&2, K>, MI.ceiling_key(~K, ~V, ~cmp, m, k)) : M.TreeMap<K, V, cmp> & Maybe<&2, K>}:
  %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.navigate(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k, True{}, True{}), MI.rp(~K, ~V, ~cmp, Nat, MI.navigate(~K, ~V, ~cmp, m, k, True{}, True{})), navigate_s(~K, ~V, ~cmp, m, k, True{}, True{}, g_m)) : {M.key_id(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, K>, MI.ceiling_key(~K, ~V, ~cmp, m, k)) : M.TreeMap<K, V, cmp> & Maybe<&2, K>}
  key_id_s(~K, ~V, ~cmp, MI.navigate(~K, ~V, ~cmp, m, k, True{}, True{}), navigate_g(~K, ~V, ~cmp, m, k, True{}, True{}, g_m))


def higher_key_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, K>, MI.higher_key(~K, ~V, ~cmp, m, k)) == True{} : Bool}:
  key_id_g(~K, ~V, ~cmp, MI.navigate(~K, ~V, ~cmp, m, k, True{}, False{}), navigate_g(~K, ~V, ~cmp, m, k, True{}, False{}, g_m))

def higher_key_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.higher_key(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k) == MI.rp(~K, ~V, ~cmp, Maybe<&2, K>, MI.higher_key(~K, ~V, ~cmp, m, k)) : M.TreeMap<K, V, cmp> & Maybe<&2, K>}:
  %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.navigate(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k, True{}, False{}), MI.rp(~K, ~V, ~cmp, Nat, MI.navigate(~K, ~V, ~cmp, m, k, True{}, False{})), navigate_s(~K, ~V, ~cmp, m, k, True{}, False{}, g_m)) : {M.key_id(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, K>, MI.higher_key(~K, ~V, ~cmp, m, k)) : M.TreeMap<K, V, cmp> & Maybe<&2, K>}
  key_id_s(~K, ~V, ~cmp, MI.navigate(~K, ~V, ~cmp, m, k, True{}, False{}), navigate_g(~K, ~V, ~cmp, m, k, True{}, False{}, g_m))


def lower_entry_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, M.Entry<K, V>>, MI.lower_entry(~K, ~V, ~cmp, m, k)) == True{} : Bool}:
  entry_snapshot_g(~K, ~V, ~cmp, MI.navigate(~K, ~V, ~cmp, m, k, False{}, False{}), navigate_g(~K, ~V, ~cmp, m, k, False{}, False{}, g_m))

def lower_entry_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.lower_entry(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.lower_entry(~K, ~V, ~cmp, m, k)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
  %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.navigate(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k, False{}, False{}), MI.rp(~K, ~V, ~cmp, Nat, MI.navigate(~K, ~V, ~cmp, m, k, False{}, False{})), navigate_s(~K, ~V, ~cmp, m, k, False{}, False{}, g_m)) : {M.entry_snapshot(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.lower_entry(~K, ~V, ~cmp, m, k)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
  entry_snapshot_s(~K, ~V, ~cmp, MI.navigate(~K, ~V, ~cmp, m, k, False{}, False{}), navigate_g(~K, ~V, ~cmp, m, k, False{}, False{}, g_m))


def floor_entry_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, M.Entry<K, V>>, MI.floor_entry(~K, ~V, ~cmp, m, k)) == True{} : Bool}:
  entry_snapshot_g(~K, ~V, ~cmp, MI.navigate(~K, ~V, ~cmp, m, k, False{}, True{}), navigate_g(~K, ~V, ~cmp, m, k, False{}, True{}, g_m))

def floor_entry_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.floor_entry(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.floor_entry(~K, ~V, ~cmp, m, k)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
  %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.navigate(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k, False{}, True{}), MI.rp(~K, ~V, ~cmp, Nat, MI.navigate(~K, ~V, ~cmp, m, k, False{}, True{})), navigate_s(~K, ~V, ~cmp, m, k, False{}, True{}, g_m)) : {M.entry_snapshot(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.floor_entry(~K, ~V, ~cmp, m, k)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
  entry_snapshot_s(~K, ~V, ~cmp, MI.navigate(~K, ~V, ~cmp, m, k, False{}, True{}), navigate_g(~K, ~V, ~cmp, m, k, False{}, True{}, g_m))


def ceiling_entry_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, M.Entry<K, V>>, MI.ceiling_entry(~K, ~V, ~cmp, m, k)) == True{} : Bool}:
  entry_snapshot_g(~K, ~V, ~cmp, MI.navigate(~K, ~V, ~cmp, m, k, True{}, True{}), navigate_g(~K, ~V, ~cmp, m, k, True{}, True{}, g_m))

def ceiling_entry_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.ceiling_entry(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.ceiling_entry(~K, ~V, ~cmp, m, k)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
  %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.navigate(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k, True{}, True{}), MI.rp(~K, ~V, ~cmp, Nat, MI.navigate(~K, ~V, ~cmp, m, k, True{}, True{})), navigate_s(~K, ~V, ~cmp, m, k, True{}, True{}, g_m)) : {M.entry_snapshot(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.ceiling_entry(~K, ~V, ~cmp, m, k)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
  entry_snapshot_s(~K, ~V, ~cmp, MI.navigate(~K, ~V, ~cmp, m, k, True{}, True{}), navigate_g(~K, ~V, ~cmp, m, k, True{}, True{}, g_m))


def higher_entry_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, M.Entry<K, V>>, MI.higher_entry(~K, ~V, ~cmp, m, k)) == True{} : Bool}:
  entry_snapshot_g(~K, ~V, ~cmp, MI.navigate(~K, ~V, ~cmp, m, k, True{}, False{}), navigate_g(~K, ~V, ~cmp, m, k, True{}, False{}, g_m))

def higher_entry_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.higher_entry(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.higher_entry(~K, ~V, ~cmp, m, k)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
  %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.navigate(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k, True{}, False{}), MI.rp(~K, ~V, ~cmp, Nat, MI.navigate(~K, ~V, ~cmp, m, k, True{}, False{})), navigate_s(~K, ~V, ~cmp, m, k, True{}, False{}, g_m)) : {M.entry_snapshot(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.higher_entry(~K, ~V, ~cmp, m, k)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
  entry_snapshot_s(~K, ~V, ~cmp, MI.navigate(~K, ~V, ~cmp, m, k, True{}, False{}), navigate_g(~K, ~V, ~cmp, m, k, True{}, False{}, g_m))


def range_start_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +bound: M.Bound<K>, +forward: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.range_start(~K, ~V, ~cmp, m, bound, forward)) == True{} : Bool}:
  match bound:
    case M.Unbounded{}:
      range_unbounded_g(~K, ~V, ~cmp, m, forward, g_m)
    case M.Inclusive{+px2}:
      navigate_g(~K, ~V, ~cmp, m, px2, forward, True{}, g_m)
    case M.Exclusive{+px3}:
      navigate_g(~K, ~V, ~cmp, m, px3, forward, False{}, g_m)

def range_start_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +bound: M.Bound<K>, +forward: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.range_start(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), bound, forward) == MI.rp(~K, ~V, ~cmp, Nat, MI.range_start(~K, ~V, ~cmp, m, bound, forward)) : M.TreeMap<K, V, cmp> & Nat}:
  match bound:
    case M.Unbounded{}:
      range_unbounded_s(~K, ~V, ~cmp, m, forward, g_m)
    case M.Inclusive{+px2}:
      navigate_s(~K, ~V, ~cmp, m, px2, forward, True{}, g_m)
    case M.Exclusive{+px3}:
      navigate_s(~K, ~V, ~cmp, m, px3, forward, False{}, g_m)


def insert_side_left_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +z: Nat, +p: Nat, +g: Nat, +pn: M.Node<K>, +gn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.Fix, MI.insert_side_left_1(~K, ~V, ~cmp, z, p, g, pn, gn, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m1, +un}:
      insert_uncle_left_g(~K, ~V, ~cmp, m1, z, p, g, M.node_right(~K, gn), Nat.is_eq(z, M.node_right(~K, pn)), un, g_pair_result)

def insert_side_left_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +z: Nat, +p: Nat, +g: Nat, +pn: M.Node<K>, +gn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.insert_side_left_1(~K, ~V, ~cmp, z, p, g, pn, gn, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_side_left_1(~K, ~V, ~cmp, z, p, g, pn, gn, pair_result)) : M.TreeMap<K, V, cmp> & M.Fix}:
  match pair_result:
    case Tuple{+m1, +un}:
      insert_uncle_left_s(~K, ~V, ~cmp, m1, z, p, g, M.node_right(~K, gn), Nat.is_eq(z, M.node_right(~K, pn)), un, g_pair_result)


def insert_side_right_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +z: Nat, +p: Nat, +g: Nat, +pn: M.Node<K>, +gn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.Fix, MI.insert_side_right_1(~K, ~V, ~cmp, z, p, g, pn, gn, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m1, +un}:
      insert_uncle_right_g(~K, ~V, ~cmp, m1, z, p, g, M.node_left(~K, gn), Nat.is_eq(z, M.node_left(~K, pn)), un, g_pair_result)

def insert_side_right_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +z: Nat, +p: Nat, +g: Nat, +pn: M.Node<K>, +gn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.insert_side_right_1(~K, ~V, ~cmp, z, p, g, pn, gn, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_side_right_1(~K, ~V, ~cmp, z, p, g, pn, gn, pair_result)) : M.TreeMap<K, V, cmp> & M.Fix}:
  match pair_result:
    case Tuple{+m1, +un}:
      insert_uncle_right_s(~K, ~V, ~cmp, m1, z, p, g, M.node_left(~K, gn), Nat.is_eq(z, M.node_left(~K, pn)), un, g_pair_result)


def allocate_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +k: K, +v: V, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Result<&2, &2, M.Rejected<K, V>, Nat>, MI.allocate(~K, ~V, ~cmp, m, p, k, v)) == True{} : Bool}:
  match m:
    case ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}:
      match free:
        case 0n:
          append_g(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, 0n, l_0, d_0, nl_0, pl_0, t_0, fl_0}, k, v, p, g_m)
        case 1n+ +px2:
          alloc_read_g(~K, ~V, ~cmp, 1n+px2, p, k, v, MI.read(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, 1n+px2, l_0, d_0, nl_0, pl_0, t_0, fl_0}, 1n+px2), read_g(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, 1n+px2, l_0, d_0, nl_0, pl_0, t_0, fl_0}, 1n+px2, g_m))

def allocate_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +k: K, +v: V, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.allocate(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p, k, v) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Nat>, MI.allocate(~K, ~V, ~cmp, m, p, k, v)) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Nat>}:
  match m:
    case ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}:
      match free:
        case 0n:
          append_s(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, 0n, l_0, d_0, nl_0, pl_0, t_0, fl_0}, k, v, p, g_m)
        case 1n+ +px2:
          %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, 1n+px2, l_0, d_0, nl_0, pl_0, t_0, fl_0}), 1n+px2), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, 1n+px2, l_0, d_0, nl_0, pl_0, t_0, fl_0}, 1n+px2)), read_s(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, 1n+px2, l_0, d_0, nl_0, pl_0, t_0, fl_0}, 1n+px2, g_m)) : {M.alloc_read(~K, ~V, ~cmp, 1n+px2, p, k, v, _) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Nat>, MI.allocate(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, p, k, v)) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Nat>}
          alloc_read_s(~K, ~V, ~cmp, 1n+px2, p, k, v, MI.read(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, 1n+px2, l_0, d_0, nl_0, pl_0, t_0, fl_0}, 1n+px2), read_g(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, 1n+px2, l_0, d_0, nl_0, pl_0, t_0, fl_0}, 1n+px2, g_m))


def successor_ready_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +target: Nat, r: ST.Sh<K, V> & Nat, +g_r: {MI.dgp(K, V, Nat, r) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.successor_ready(~K, ~V, ~cmp, target, r)) == True{} : Bool}:
  match r:
    case Tuple{+m, +source}:
      move_successor_g(~K, ~V, ~cmp, m, target, source, g_r)

def successor_ready_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +target: Nat, r: ST.Sh<K, V> & Nat, +g_r: {MI.dgp(K, V, Nat, r) == True{} : Bool}) -> {M.successor_ready(~K, ~V, ~cmp, target, MI.rp(~K, ~V, ~cmp, Nat, r)) == MI.rp(~K, ~V, ~cmp, Nat, MI.successor_ready(~K, ~V, ~cmp, target, r)) : M.TreeMap<K, V, cmp> & Nat}:
  match r:
    case Tuple{+m, +source}:
      move_successor_s(~K, ~V, ~cmp, m, target, source, g_r)


def delete_borrow_read_left_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_borrow_read_left_1(~K, ~V, ~cmp, p, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m1, +pn}:
      delete_borrow_read_left_2_g(~K, ~V, ~cmp, p, pn, MI.read(~K, ~V, ~cmp, m1, M.node_right(~K, pn)), read_g(~K, ~V, ~cmp, m1, M.node_right(~K, pn), g_pair_result))

def delete_borrow_read_left_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.delete_borrow_read_left_1(~K, ~V, ~cmp, p, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_borrow_read_left_1(~K, ~V, ~cmp, p, pair_result)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
  match pair_result:
    case Tuple{+m1, +pn}:
      %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m1), M.node_right(~K, pn)), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m1, M.node_right(~K, pn))), read_s(~K, ~V, ~cmp, m1, M.node_right(~K, pn), g_pair_result)) : {M.delete_borrow_read_left_2(~K, ~V, ~cmp, p, pn, _) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_borrow_read_left_1(~K, ~V, ~cmp, p, Tuple{m1, pn})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
      delete_borrow_read_left_2_s(~K, ~V, ~cmp, p, pn, MI.read(~K, ~V, ~cmp, m1, M.node_right(~K, pn)), read_g(~K, ~V, ~cmp, m1, M.node_right(~K, pn), g_pair_result))


def delete_borrow_read_right_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_borrow_read_right_1(~K, ~V, ~cmp, p, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m1, +pn}:
      delete_borrow_read_right_2_g(~K, ~V, ~cmp, p, pn, MI.read(~K, ~V, ~cmp, m1, M.node_left(~K, pn)), read_g(~K, ~V, ~cmp, m1, M.node_left(~K, pn), g_pair_result))

def delete_borrow_read_right_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.delete_borrow_read_right_1(~K, ~V, ~cmp, p, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_borrow_read_right_1(~K, ~V, ~cmp, p, pair_result)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
  match pair_result:
    case Tuple{+m1, +pn}:
      %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m1), M.node_left(~K, pn)), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m1, M.node_left(~K, pn))), read_s(~K, ~V, ~cmp, m1, M.node_left(~K, pn), g_pair_result)) : {M.delete_borrow_read_right_2(~K, ~V, ~cmp, p, pn, _) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_borrow_read_right_1(~K, ~V, ~cmp, p, Tuple{m1, pn})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
      delete_borrow_read_right_2_s(~K, ~V, ~cmp, p, pn, MI.read(~K, ~V, ~cmp, m1, M.node_left(~K, pn)), read_g(~K, ~V, ~cmp, m1, M.node_left(~K, pn), g_pair_result))


def view_iterator_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {MI.dgc(K, V, MI.view_iterator(~K, ~V, ~cmp, view)) == True{} : Bool}:
  match view:
    case MI.MV{+m, +lower, +upper, +descending}:
      cursor_started_g(~K, ~V, ~cmp, lower, upper, Bool.not(descending), MI.range_start(~K, ~V, ~cmp, m, M.pick(M.Bound<K>, descending, upper, lower), Bool.not(descending)), range_start_g(~K, ~V, ~cmp, m, M.pick(M.Bound<K>, descending, upper, lower), Bool.not(descending), g_view))

def view_iterator_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {M.view_iterator(~K, ~V, ~cmp, MI.rv(~K, ~V, ~cmp, view)) == MI.rc(~K, ~V, ~cmp, MI.view_iterator(~K, ~V, ~cmp, view)) : M.Cursor<K, V, cmp>}:
  match view:
    case MI.MV{+m, +lower, +upper, +descending}:
      %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.range_start(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), M.pick(M.Bound<K>, descending, upper, lower), Bool.not(descending)), MI.rp(~K, ~V, ~cmp, Nat, MI.range_start(~K, ~V, ~cmp, m, M.pick(M.Bound<K>, descending, upper, lower), Bool.not(descending))), range_start_s(~K, ~V, ~cmp, m, M.pick(M.Bound<K>, descending, upper, lower), Bool.not(descending), g_view)) : {M.cursor_started(~K, ~V, ~cmp, lower, upper, Bool.not(descending), _) == MI.rc(~K, ~V, ~cmp, MI.view_iterator(~K, ~V, ~cmp, MI.MV{m, lower, upper, descending})) : M.Cursor<K, V, cmp>}
      cursor_started_s(~K, ~V, ~cmp, lower, upper, Bool.not(descending), MI.range_start(~K, ~V, ~cmp, m, M.pick(M.Bound<K>, descending, upper, lower), Bool.not(descending)), range_start_g(~K, ~V, ~cmp, m, M.pick(M.Bound<K>, descending, upper, lower), Bool.not(descending), g_view))


def view_nav_start_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +lower: M.Bound<K>, +upper: M.Bound<K>, +higher: Bool, +inclusive: Bool, +within: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.view_nav_start(~K, ~V, ~cmp, m, k, lower, upper, higher, inclusive, within)) == True{} : Bool}:
  match within:
    case True{}:
      navigate_g(~K, ~V, ~cmp, m, k, higher, inclusive, g_m)
    case False{}:
      range_start_g(~K, ~V, ~cmp, m, M.pick(M.Bound<K>, higher, lower, upper), higher, g_m)

def view_nav_start_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +lower: M.Bound<K>, +upper: M.Bound<K>, +higher: Bool, +inclusive: Bool, +within: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.view_nav_start(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k, lower, upper, higher, inclusive, within) == MI.rp(~K, ~V, ~cmp, Nat, MI.view_nav_start(~K, ~V, ~cmp, m, k, lower, upper, higher, inclusive, within)) : M.TreeMap<K, V, cmp> & Nat}:
  match within:
    case True{}:
      navigate_s(~K, ~V, ~cmp, m, k, higher, inclusive, g_m)
    case False{}:
      range_start_s(~K, ~V, ~cmp, m, M.pick(M.Bound<K>, higher, lower, upper), higher, g_m)


def view_extreme_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +first: Bool, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {MI.dgvp(K, V, Maybe<&2, M.Entry<K, V>>, MI.view_extreme(~K, ~V, ~cmp, view, first)) == True{} : Bool}:
  match view:
    case MI.MV{+m, +lower, +upper, +descending}:
      +up = M.pick(Bool, descending, Bool.not(first), first)
      view_entry_result_g(~K, ~V, ~cmp, lower, upper, descending, MI.entry_snapshot(~K, ~V, ~cmp, MI.range_start(~K, ~V, ~cmp, m, M.pick(M.Bound<K>, up, lower, upper), up)), entry_snapshot_g(~K, ~V, ~cmp, MI.range_start(~K, ~V, ~cmp, m, M.pick(M.Bound<K>, up, lower, upper), up), range_start_g(~K, ~V, ~cmp, m, M.pick(M.Bound<K>, up, lower, upper), up, g_view)))

def view_extreme_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +first: Bool, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {M.view_extreme(~K, ~V, ~cmp, MI.rv(~K, ~V, ~cmp, view), first) == MI.rvp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.view_extreme(~K, ~V, ~cmp, view, first)) : M.View<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
  match view:
    case MI.MV{+m, +lower, +upper, +descending}:
      +up = M.pick(Bool, descending, Bool.not(first), first)
      %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.range_start(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), M.pick(M.Bound<K>, up, lower, upper), up), MI.rp(~K, ~V, ~cmp, Nat, MI.range_start(~K, ~V, ~cmp, m, M.pick(M.Bound<K>, up, lower, upper), up)), range_start_s(~K, ~V, ~cmp, m, M.pick(M.Bound<K>, up, lower, upper), up, g_view)) : {M.view_entry_result(~K, ~V, ~cmp, lower, upper, descending, M.entry_snapshot(~K, ~V, ~cmp, _)) == MI.rvp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.view_extreme(~K, ~V, ~cmp, MI.MV{m, lower, upper, descending}, first)) : M.View<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
      %Equal.sym(M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>, M.entry_snapshot(~K, ~V, ~cmp, MI.rp(~K, ~V, ~cmp, Nat, MI.range_start(~K, ~V, ~cmp, m, M.pick(M.Bound<K>, up, lower, upper), up))), MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.entry_snapshot(~K, ~V, ~cmp, MI.range_start(~K, ~V, ~cmp, m, M.pick(M.Bound<K>, up, lower, upper), up))), entry_snapshot_s(~K, ~V, ~cmp, MI.range_start(~K, ~V, ~cmp, m, M.pick(M.Bound<K>, up, lower, upper), up), range_start_g(~K, ~V, ~cmp, m, M.pick(M.Bound<K>, up, lower, upper), up, g_view))) : {M.view_entry_result(~K, ~V, ~cmp, lower, upper, descending, _) == MI.rvp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.view_extreme(~K, ~V, ~cmp, MI.MV{m, lower, upper, descending}, first)) : M.View<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
      view_entry_result_s(~K, ~V, ~cmp, lower, upper, descending, MI.entry_snapshot(~K, ~V, ~cmp, MI.range_start(~K, ~V, ~cmp, m, M.pick(M.Bound<K>, up, lower, upper), up)), entry_snapshot_g(~K, ~V, ~cmp, MI.range_start(~K, ~V, ~cmp, m, M.pick(M.Bound<K>, up, lower, upper), up), range_start_g(~K, ~V, ~cmp, m, M.pick(M.Bound<K>, up, lower, upper), up, g_view)))


def insert_side_left_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +z: Nat, +p: Nat, +g: Nat, +pn: M.Node<K>, +gn: M.Node<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.Fix, MI.insert_side_left(~K, ~V, ~cmp, m, z, p, g, pn, gn)) == True{} : Bool}:
  insert_side_left_1_g(~K, ~V, ~cmp, z, p, g, pn, gn, MI.read(~K, ~V, ~cmp, m, M.node_right(~K, gn)), read_g(~K, ~V, ~cmp, m, M.node_right(~K, gn), g_m))

def insert_side_left_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +z: Nat, +p: Nat, +g: Nat, +pn: M.Node<K>, +gn: M.Node<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.insert_side_left(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), z, p, g, pn, gn) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_side_left(~K, ~V, ~cmp, m, z, p, g, pn, gn)) : M.TreeMap<K, V, cmp> & M.Fix}:
  %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), M.node_right(~K, gn)), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m, M.node_right(~K, gn))), read_s(~K, ~V, ~cmp, m, M.node_right(~K, gn), g_m)) : {M.insert_side_left_1(~K, ~V, ~cmp, z, p, g, pn, gn, _) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_side_left(~K, ~V, ~cmp, m, z, p, g, pn, gn)) : M.TreeMap<K, V, cmp> & M.Fix}
  insert_side_left_1_s(~K, ~V, ~cmp, z, p, g, pn, gn, MI.read(~K, ~V, ~cmp, m, M.node_right(~K, gn)), read_g(~K, ~V, ~cmp, m, M.node_right(~K, gn), g_m))


def insert_side_right_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +z: Nat, +p: Nat, +g: Nat, +pn: M.Node<K>, +gn: M.Node<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.Fix, MI.insert_side_right(~K, ~V, ~cmp, m, z, p, g, pn, gn)) == True{} : Bool}:
  insert_side_right_1_g(~K, ~V, ~cmp, z, p, g, pn, gn, MI.read(~K, ~V, ~cmp, m, M.node_left(~K, gn)), read_g(~K, ~V, ~cmp, m, M.node_left(~K, gn), g_m))

def insert_side_right_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +z: Nat, +p: Nat, +g: Nat, +pn: M.Node<K>, +gn: M.Node<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.insert_side_right(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), z, p, g, pn, gn) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_side_right(~K, ~V, ~cmp, m, z, p, g, pn, gn)) : M.TreeMap<K, V, cmp> & M.Fix}:
  %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), M.node_left(~K, gn)), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m, M.node_left(~K, gn))), read_s(~K, ~V, ~cmp, m, M.node_left(~K, gn), g_m)) : {M.insert_side_right_1(~K, ~V, ~cmp, z, p, g, pn, gn, _) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_side_right(~K, ~V, ~cmp, m, z, p, g, pn, gn)) : M.TreeMap<K, V, cmp> & M.Fix}
  insert_side_right_1_s(~K, ~V, ~cmp, z, p, g, pn, gn, MI.read(~K, ~V, ~cmp, m, M.node_left(~K, gn)), read_g(~K, ~V, ~cmp, m, M.node_left(~K, gn), g_m))


def delete_target_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, r: ST.Sh<K, V> & M.Node<K>, +g_r: {MI.dgp(K, V, M.Node<K>, r) == True{} : Bool}) -> {MI.dgp(K, V, Nat, MI.delete_target(~K, ~V, ~cmp, id, r)) == True{} : Bool}:
  match r:
    case Tuple{+px2, M.N{+px5, 1n+ +px10, 1n+ +px11, +px8, +px9}}:
      successor_ready_g(~K, ~V, ~cmp, id, MI.extreme(~K, ~V, ~cmp, px2, 1n+px11, False{}), extreme_g(~K, ~V, ~cmp, px2, 1n+px11, False{}, g_r))
    case Tuple{+px2, M.Free{+px4}}:
      g_r
    case Tuple{+px2, M.N{+px5, 0n, 0n, +px8, +px9}}:
      g_r
    case Tuple{+px2, M.N{+px5, 0n, 1n+ +px12, +px8, +px9}}:
      g_r
    case Tuple{+px2, M.N{+px5, 1n+ +px10, 0n, +px8, +px9}}:
      g_r

def delete_target_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, r: ST.Sh<K, V> & M.Node<K>, +g_r: {MI.dgp(K, V, M.Node<K>, r) == True{} : Bool}) -> {M.delete_target(~K, ~V, ~cmp, id, MI.rp(~K, ~V, ~cmp, M.Node<K>, r)) == MI.rp(~K, ~V, ~cmp, Nat, MI.delete_target(~K, ~V, ~cmp, id, r)) : M.TreeMap<K, V, cmp> & Nat}:
  match r:
    case Tuple{+px2, M.N{+px5, 1n+ +px10, 1n+ +px11, +px8, +px9}}:
      %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.extreme(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, px2), 1n+px11, False{}), MI.rp(~K, ~V, ~cmp, Nat, MI.extreme(~K, ~V, ~cmp, px2, 1n+px11, False{})), extreme_s(~K, ~V, ~cmp, px2, 1n+px11, False{}, g_r)) : {M.successor_ready(~K, ~V, ~cmp, id, _) == MI.rp(~K, ~V, ~cmp, Nat, MI.delete_target(~K, ~V, ~cmp, id, Tuple{px2, M.N{px5, 1n+ px10, 1n+ px11, px8, px9}})) : M.TreeMap<K, V, cmp> & Nat}
      successor_ready_s(~K, ~V, ~cmp, id, MI.extreme(~K, ~V, ~cmp, px2, 1n+px11, False{}), extreme_g(~K, ~V, ~cmp, px2, 1n+px11, False{}, g_r))
    case Tuple{+px2, M.Free{+px4}}:
      {==}
    case Tuple{+px2, M.N{+px5, 0n, 0n, +px8, +px9}}:
      {==}
    case Tuple{+px2, M.N{+px5, 0n, 1n+ +px12, +px8, +px9}}:
      {==}
    case Tuple{+px2, M.N{+px5, 1n+ +px10, 0n, +px8, +px9}}:
      {==}


def delete_borrow_read_left_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_borrow_read_left(~K, ~V, ~cmp, m, p)) == True{} : Bool}:
  delete_borrow_read_left_1_g(~K, ~V, ~cmp, p, MI.read(~K, ~V, ~cmp, m, p), read_g(~K, ~V, ~cmp, m, p, g_m))

def delete_borrow_read_left_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.delete_borrow_read_left(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_borrow_read_left(~K, ~V, ~cmp, m, p)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
  %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m, p)), read_s(~K, ~V, ~cmp, m, p, g_m)) : {M.delete_borrow_read_left_1(~K, ~V, ~cmp, p, _) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_borrow_read_left(~K, ~V, ~cmp, m, p)) : M.TreeMap<K, V, cmp> & M.DeleteFix}
  delete_borrow_read_left_1_s(~K, ~V, ~cmp, p, MI.read(~K, ~V, ~cmp, m, p), read_g(~K, ~V, ~cmp, m, p, g_m))


def delete_borrow_read_right_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_borrow_read_right(~K, ~V, ~cmp, m, p)) == True{} : Bool}:
  delete_borrow_read_right_1_g(~K, ~V, ~cmp, p, MI.read(~K, ~V, ~cmp, m, p), read_g(~K, ~V, ~cmp, m, p, g_m))

def delete_borrow_read_right_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.delete_borrow_read_right(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_borrow_read_right(~K, ~V, ~cmp, m, p)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
  %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m, p)), read_s(~K, ~V, ~cmp, m, p, g_m)) : {M.delete_borrow_read_right_1(~K, ~V, ~cmp, p, _) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_borrow_read_right(~K, ~V, ~cmp, m, p)) : M.TreeMap<K, V, cmp> & M.DeleteFix}
  delete_borrow_read_right_1_s(~K, ~V, ~cmp, p, MI.read(~K, ~V, ~cmp, m, p), read_g(~K, ~V, ~cmp, m, p, g_m))


# ---- iterator_next: the step reads four fields, the mirror's step the whole node ----


# the child the step reads is the one the node's neighbour walk starts from
def iq_f(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +i: Nat, +lower: M.Bound<K>, +upper: M.Bound<K>, +fw: Bool, +key: K, +v: V, +c: Bool, +lf: Nat, +rt: Nat, +q: Nat) -> {M.iterator_yield(~K, ~V, ~cmp, 1n+i, lower, upper, fw, M.Entry{key, v}, M.neighbor_slots_finish(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), M.neighbor_slots(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), n, 1n+i, q, fw, M.pick(Nat, Bool.not(fw), lf, rt)))) == M.iterator_yield(~K, ~V, ~cmp, 1n+i, lower, upper, fw, M.Entry{key, v}, M.neighbor_node(~K, ~V, ~cmp, 1n+i, fw, (ST.real(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}), M.N{c, lf, rt, q, key}))) : M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
  match fw:
    case True{}:
      {==}
    case False{}:
      {==}

# in range: parent and child reads, then the mirror's neighbour and yield
def iq_v(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)) == True{} : Bool}, +g: {MI.dg(K, V, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}) == True{} : Bool}, +i: Nat, +cur: Nat, +lower: M.Bound<K>, +upper: M.Bound<K>, +fw: Bool, +c: Bool, +lf: Nat, +rt: Nat, +q: Nat, +key: K, +v: V, +hy: {ST.nth_or(M.Node<K>, nl, i, M.Free{0n}) == M.N{c, lf, rt, q, key} : M.Node<K>}, +b: Bool) -> {M.iter_valid(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), ST.nodes(~K, l, d, nl), i, cur, lower, upper, fw, M.Entry{key, v}, b) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.iterator_checked(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, 1n+i, cur, lower, upper, fw, M.N{c, lf, rt, q, key}, M.Entry{key, v}, b)) : M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
  match b:
    case False{}:
      {==}
    case True{}:
      %Equal.sym(M.NodeStore<K> & Nat, M.ns_parent_at(~K, ST.nodes(~K, l, d, nl), i), (ST.nodes(~K, l, d, nl), M.nparent(~K, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}))), NSL.parent_at_ok(~K, l, d, nl, hl, hd, hc, i)) : {M.iter_link(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), i, lower, upper, fw, M.Entry{key, v}, _) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.iterator_yield(~K, ~V, ~cmp, 1n+i, lower, upper, fw, M.Entry{key, v}, MI.neighbor_node(~K, ~V, ~cmp, 1n+i, fw, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, M.N{c, lf, rt, q, key})))) : M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
      %Equal.sym(M.Node<K>, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}), M.N{c, lf, rt, q, key}, hy) : {M.iter_link(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), i, lower, upper, fw, M.Entry{key, v}, (ST.nodes(~K, l, d, nl), M.nparent(~K, _))) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.iterator_yield(~K, ~V, ~cmp, 1n+i, lower, upper, fw, M.Entry{key, v}, MI.neighbor_node(~K, ~V, ~cmp, 1n+i, fw, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, M.N{c, lf, rt, q, key})))) : M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
      %Equal.sym(M.NodeStore<K> & Nat, M.side_at(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), Bool.not(fw), i), (ST.nodes(~K, l, d, nl), M.pick(Nat, Bool.not(fw), M.nleft(~K, ST.nth_or(M.Node<K>, nl, i, M.Free{0n})), M.nright(~K, ST.nth_or(M.Node<K>, nl, i, M.Free{0n})))), side_ok(~K, ~V, ~cmp, l, d, nl, hl, hd, hc, Bool.not(fw), i)) : {M.iter_child(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), 1n+i, lower, upper, fw, M.Entry{key, v}, q, _) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.iterator_yield(~K, ~V, ~cmp, 1n+i, lower, upper, fw, M.Entry{key, v}, MI.neighbor_node(~K, ~V, ~cmp, 1n+i, fw, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, M.N{c, lf, rt, q, key})))) : M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
      %Equal.sym(M.Node<K>, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}), M.N{c, lf, rt, q, key}, hy) : {M.iter_child(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), 1n+i, lower, upper, fw, M.Entry{key, v}, q, (ST.nodes(~K, l, d, nl), M.pick(Nat, Bool.not(fw), M.nleft(~K, _), M.nright(~K, _)))) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.iterator_yield(~K, ~V, ~cmp, 1n+i, lower, upper, fw, M.Entry{key, v}, MI.neighbor_node(~K, ~V, ~cmp, 1n+i, fw, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, M.N{c, lf, rt, q, key})))) : M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
      %iterator_yield_s(~K, ~V, ~cmp, 1n+i, lower, upper, fw, M.Entry{key, v}, MI.neighbor_node(~K, ~V, ~cmp, 1n+i, fw, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, M.N{c, lf, rt, q, key})), neighbor_node_g(~K, ~V, ~cmp, 1n+i, fw, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, M.N{c, lf, rt, q, key}), g)) : {M.iterator_yield(~K, ~V, ~cmp, 1n+i, lower, upper, fw, M.Entry{key, v}, M.neighbor_slots_finish(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), M.neighbor_slots(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), n, 1n+i, q, fw, M.pick(Nat, Bool.not(fw), lf, rt)))) == _ : M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
      %neighbor_node_s(~K, ~V, ~cmp, 1n+i, fw, (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, M.N{c, lf, rt, q, key}), g) : {M.iterator_yield(~K, ~V, ~cmp, 1n+i, lower, upper, fw, M.Entry{key, v}, M.neighbor_slots_finish(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), M.neighbor_slots(~K, ~V, ~cmp, ST.nodes(~K, l, d, nl), n, 1n+i, q, fw, M.pick(Nat, Bool.not(fw), lf, rt)))) == M.iterator_yield(~K, ~V, ~cmp, 1n+i, lower, upper, fw, M.Entry{key, v}, _) : M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
      iq_f(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, i, lower, upper, fw, key, v, c, lf, rt, q)

# the key and the value decide: a live node with a value is checked, else the walk ends
def iq_y(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)) == True{} : Bool}, +g: {MI.dg(K, V, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}) == True{} : Bool}, +i: Nat, +cur: Nat, +lower: M.Bound<K>, +upper: M.Bound<K>, +fw: Bool, +y: M.Node<K>, +hy: {ST.nth_or(M.Node<K>, nl, i, M.Free{0n}) == y : M.Node<K>}, +w: Maybe<&2, V>) -> {M.iter_kv(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), ST.nodes(~K, l, d, nl), i, cur, lower, upper, fw, M.nkey(~K, y), w) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.iterator_read(~K, ~V, ~cmp, 1n+i, cur, lower, upper, fw, y, MI.entry_value(~K, ~V, ~cmp, M.node_key(~K, y), (ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, w)))) : M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
  match y w:
    case M.Free{z} None{}:
      {==}
    case M.Free{z} Some{x}:
      {==}
    case M.N{c, lf, rt, q, key} None{}:
      {==}
    case M.N{+c, +lf, +rt, +q, +key} Some{+v}:
      iq_v(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, hl, hd, hc, hp, g, i, cur, lower, upper, fw, c, lf, rt, q, key, v, hy, M.in_range(~K, ~V, ~cmp, key, lower, upper))

def iq_n(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +n: Nat, +root: Nat, +lo: Nat, +hi: Nat, +free: Nat, +l: Nat, +d: Nat, +nl: List<&2, M.Node<K>>, +pl: List<&2, Maybe<&2, V>>, +t: ST.Tr, +fl: List<&2, Nat>, +hl: {Nat.is_le(l, 31n) == True{} : Bool}, +hd: {Nat.is_le(d, l) == True{} : Bool}, +hc: {Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)) == True{} : Bool}, +hp: {Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)) == True{} : Bool}, +g: {MI.dg(K, V, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}) == True{} : Bool}, +next: Nat, +cur: Nat, +lower: M.Bound<K>, +upper: M.Bound<K>, +fw: Bool) -> {M.iter_at(~K, ~V, ~cmp, next, cur, lower, upper, fw, ST.real(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl})) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.iterator_next(~K, ~V, ~cmp, MI.MC{ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, next, cur, lower, upper, fw})) : M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
  match next:
    case 0n:
      {==}
    case 1n+ +i:
      %Equal.sym(M.TreeMap<K, V, cmp> & Maybe<&2, V>, M.get_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}), 1n+i), (ST.real(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}), ST.pv(V, pl, 1n+i)), PR.get_id_c(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, hl, hd, hc, hp, 1n+i)) : {M.iter_value(~K, ~V, ~cmp, i, cur, lower, upper, fw, _) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.iterator_next(~K, ~V, ~cmp, MI.MC{ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, 1n+i, cur, lower, upper, fw})) : M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
      %Equal.sym(M.NodeStore<K> & Maybe<&2, K>, M.ns_key_at(~K, ST.nodes(~K, l, d, nl), i), (ST.nodes(~K, l, d, nl), M.nkey(~K, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}))), NSL.key_at_ok(~K, l, d, nl, hl, hd, hc, i)) : {M.iter_key(~K, ~V, ~cmp, n, root, lo, hi, free, ST.pays(~V, l, d, pl), i, cur, lower, upper, fw, ST.nth_or(Maybe<&2, V>, pl, i, None{}), _) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.iterator_next(~K, ~V, ~cmp, MI.MC{ST.SH{n, root, lo, hi, free, l, d, nl, pl, t, fl}, 1n+i, cur, lower, upper, fw})) : M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
      iq_y(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, hl, hd, hc, hp, g, i, cur, lower, upper, fw, ST.nth_or(M.Node<K>, nl, i, M.Free{0n}), {==}, ST.nth_or(Maybe<&2, V>, pl, i, None{}))

def iq_m(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +next: Nat, +cur: Nat, +lower: M.Bound<K>, +upper: M.Bound<K>, +fw: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.iter_at(~K, ~V, ~cmp, next, cur, lower, upper, fw, ST.real(~K, ~V, ~cmp, m)) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.iterator_next(~K, ~V, ~cmp, MI.MC{m, next, cur, lower, upper, fw})) : M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
  match m:
    case ST.SH{+n, +root, +lo, +hi, +free, +l, +d, +nl, +pl, +t, +fl}:
      iq_n(~K, ~V, ~cmp, n, root, lo, hi, free, l, d, nl, pl, t, fl, L.and_left(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m), L.and_left(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m)), L.and_left(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), L.and_right(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)), L.and_right(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl))), L.and_right(Nat.is_le(l, 31n), Bool.and(Nat.is_le(d, l), Bool.and(Nat.is_le(SC.length(M.Node<K>, nl), SC.pow2(d)), Nat.is_eq(SC.length(Maybe<&2, V>, pl), SC.length(M.Node<K>, nl)))), g_m))), g_m, next, cur, lower, upper, fw)

def iterator_next_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +cursor: MI.MCursor<K, V>, +g_cursor: {MI.dgc(K, V, cursor) == True{} : Bool}) -> {M.iterator_next(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, cursor)) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.iterator_next(~K, ~V, ~cmp, cursor)) : M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
  match cursor:
    case MI.MC{+m, +next, +current, +lower, +upper, +forward}:
      iq_m(~K, ~V, ~cmp, m, next, current, lower, upper, forward, g_cursor)

def iterator_checked_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +current: Nat, +lower: M.Bound<K>, +upper: M.Bound<K>, +forward: Bool, +node: M.Node<K>, +entry: M.Entry<K, V>, +valid: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgcp(K, V, Maybe<&2, M.Entry<K, V>>, MI.iterator_checked(~K, ~V, ~cmp, m, id, current, lower, upper, forward, node, entry, valid)) == True{} : Bool}:
  match valid:
    case True{}:
      iterator_yield_g(~K, ~V, ~cmp, id, lower, upper, forward, entry, MI.neighbor_node(~K, ~V, ~cmp, id, forward, (m, node)), neighbor_node_g(~K, ~V, ~cmp, id, forward, (m, node), g_m))
    case False{}:
      g_m

def iterator_read_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +current: Nat, +lower: M.Bound<K>, +upper: M.Bound<K>, +forward: Bool, +node: M.Node<K>, r: ST.Sh<K, V> & Maybe<&2, M.Entry<K, V>>, +g_r: {MI.dgp(K, V, Maybe<&2, M.Entry<K, V>>, r) == True{} : Bool}) -> {MI.dgcp(K, V, Maybe<&2, M.Entry<K, V>>, MI.iterator_read(~K, ~V, ~cmp, id, current, lower, upper, forward, node, r)) == True{} : Bool}:
  match r:
    case Tuple{+px2, None{}}:
      g_r
    case Tuple{+px2, Some{M.Entry{+px5, +px6}}}:
      iterator_checked_g(~K, ~V, ~cmp, px2, id, current, lower, upper, forward, node, M.Entry{px5, px6}, M.in_range(~K, ~V, ~cmp, px5, lower, upper), g_r)

def iterator_node_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +current: Nat, +lower: M.Bound<K>, +upper: M.Bound<K>, +forward: Bool, r: ST.Sh<K, V> & M.Node<K>, +g_r: {MI.dgp(K, V, M.Node<K>, r) == True{} : Bool}) -> {MI.dgcp(K, V, Maybe<&2, M.Entry<K, V>>, MI.iterator_node(~K, ~V, ~cmp, id, current, lower, upper, forward, r)) == True{} : Bool}:
  match r:
    case Tuple{+m, +node}:
      iterator_read_g(~K, ~V, ~cmp, id, current, lower, upper, forward, node, MI.entry_value(~K, ~V, ~cmp, M.node_key(~K, node), MI.get_id(~K, ~V, ~cmp, m, id)), entry_value_g(~K, ~V, ~cmp, M.node_key(~K, node), MI.get_id(~K, ~V, ~cmp, m, id), get_id_g(~K, ~V, ~cmp, m, id, g_r)))

def iterator_next_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +cursor: MI.MCursor<K, V>, +g_cursor: {MI.dgc(K, V, cursor) == True{} : Bool}) -> {MI.dgcp(K, V, Maybe<&2, M.Entry<K, V>>, MI.iterator_next(~K, ~V, ~cmp, cursor)) == True{} : Bool}:
  match cursor:
    case MI.MC{+m, +next, +current, +lower, +upper, +forward}:
      iterator_node_g(~K, ~V, ~cmp, next, current, lower, upper, forward, MI.read(~K, ~V, ~cmp, m, next), read_g(~K, ~V, ~cmp, m, next, g_cursor))


def view_nav_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +k: K, +higher: Bool, +inclusive: Bool, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {MI.dgvp(K, V, Maybe<&2, M.Entry<K, V>>, MI.view_nav(~K, ~V, ~cmp, view, k, higher, inclusive)) == True{} : Bool}:
  match view:
    case MI.MV{+m, +lower, +upper, +descending}:
      +up = M.pick(Bool, descending, Bool.not(higher), higher)
      view_entry_result_g(~K, ~V, ~cmp, lower, upper, descending, MI.entry_snapshot(~K, ~V, ~cmp, MI.view_nav_start(~K, ~V, ~cmp, m, k, lower, upper, up, inclusive, M.pick(Bool, up, M.above_lower(~K, ~V, ~cmp, k, lower), M.below_upper(~K, ~V, ~cmp, k, upper)))), entry_snapshot_g(~K, ~V, ~cmp, MI.view_nav_start(~K, ~V, ~cmp, m, k, lower, upper, up, inclusive, M.pick(Bool, up, M.above_lower(~K, ~V, ~cmp, k, lower), M.below_upper(~K, ~V, ~cmp, k, upper))), view_nav_start_g(~K, ~V, ~cmp, m, k, lower, upper, up, inclusive, M.pick(Bool, up, M.above_lower(~K, ~V, ~cmp, k, lower), M.below_upper(~K, ~V, ~cmp, k, upper)), g_view)))

def view_nav_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +k: K, +higher: Bool, +inclusive: Bool, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {M.view_nav(~K, ~V, ~cmp, MI.rv(~K, ~V, ~cmp, view), k, higher, inclusive) == MI.rvp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.view_nav(~K, ~V, ~cmp, view, k, higher, inclusive)) : M.View<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
  match view:
    case MI.MV{+m, +lower, +upper, +descending}:
      +up = M.pick(Bool, descending, Bool.not(higher), higher)
      %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.view_nav_start(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k, lower, upper, up, inclusive, M.pick(Bool, up, M.above_lower(~K, ~V, ~cmp, k, lower), M.below_upper(~K, ~V, ~cmp, k, upper))), MI.rp(~K, ~V, ~cmp, Nat, MI.view_nav_start(~K, ~V, ~cmp, m, k, lower, upper, up, inclusive, M.pick(Bool, up, M.above_lower(~K, ~V, ~cmp, k, lower), M.below_upper(~K, ~V, ~cmp, k, upper)))), view_nav_start_s(~K, ~V, ~cmp, m, k, lower, upper, up, inclusive, M.pick(Bool, up, M.above_lower(~K, ~V, ~cmp, k, lower), M.below_upper(~K, ~V, ~cmp, k, upper)), g_view)) : {M.view_entry_result(~K, ~V, ~cmp, lower, upper, descending, M.entry_snapshot(~K, ~V, ~cmp, _)) == MI.rvp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.view_nav(~K, ~V, ~cmp, MI.MV{m, lower, upper, descending}, k, higher, inclusive)) : M.View<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
      %Equal.sym(M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>, M.entry_snapshot(~K, ~V, ~cmp, MI.rp(~K, ~V, ~cmp, Nat, MI.view_nav_start(~K, ~V, ~cmp, m, k, lower, upper, up, inclusive, M.pick(Bool, up, M.above_lower(~K, ~V, ~cmp, k, lower), M.below_upper(~K, ~V, ~cmp, k, upper))))), MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.entry_snapshot(~K, ~V, ~cmp, MI.view_nav_start(~K, ~V, ~cmp, m, k, lower, upper, up, inclusive, M.pick(Bool, up, M.above_lower(~K, ~V, ~cmp, k, lower), M.below_upper(~K, ~V, ~cmp, k, upper))))), entry_snapshot_s(~K, ~V, ~cmp, MI.view_nav_start(~K, ~V, ~cmp, m, k, lower, upper, up, inclusive, M.pick(Bool, up, M.above_lower(~K, ~V, ~cmp, k, lower), M.below_upper(~K, ~V, ~cmp, k, upper))), view_nav_start_g(~K, ~V, ~cmp, m, k, lower, upper, up, inclusive, M.pick(Bool, up, M.above_lower(~K, ~V, ~cmp, k, lower), M.below_upper(~K, ~V, ~cmp, k, upper)), g_view))) : {M.view_entry_result(~K, ~V, ~cmp, lower, upper, descending, _) == MI.rvp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.view_nav(~K, ~V, ~cmp, MI.MV{m, lower, upper, descending}, k, higher, inclusive)) : M.View<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
      view_entry_result_s(~K, ~V, ~cmp, lower, upper, descending, MI.entry_snapshot(~K, ~V, ~cmp, MI.view_nav_start(~K, ~V, ~cmp, m, k, lower, upper, up, inclusive, M.pick(Bool, up, M.above_lower(~K, ~V, ~cmp, k, lower), M.below_upper(~K, ~V, ~cmp, k, upper)))), entry_snapshot_g(~K, ~V, ~cmp, MI.view_nav_start(~K, ~V, ~cmp, m, k, lower, upper, up, inclusive, M.pick(Bool, up, M.above_lower(~K, ~V, ~cmp, k, lower), M.below_upper(~K, ~V, ~cmp, k, upper))), view_nav_start_g(~K, ~V, ~cmp, m, k, lower, upper, up, inclusive, M.pick(Bool, up, M.above_lower(~K, ~V, ~cmp, k, lower), M.below_upper(~K, ~V, ~cmp, k, upper)), g_view)))


def view_first_entry_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {MI.dgvp(K, V, Maybe<&2, M.Entry<K, V>>, MI.view_first_entry(~K, ~V, ~cmp, view)) == True{} : Bool}:
  view_extreme_g(~K, ~V, ~cmp, view, True{}, g_view)

def view_first_entry_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {M.view_first_entry(~K, ~V, ~cmp, MI.rv(~K, ~V, ~cmp, view)) == MI.rvp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.view_first_entry(~K, ~V, ~cmp, view)) : M.View<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
  view_extreme_s(~K, ~V, ~cmp, view, True{}, g_view)


def view_last_entry_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {MI.dgvp(K, V, Maybe<&2, M.Entry<K, V>>, MI.view_last_entry(~K, ~V, ~cmp, view)) == True{} : Bool}:
  view_extreme_g(~K, ~V, ~cmp, view, False{}, g_view)

def view_last_entry_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {M.view_last_entry(~K, ~V, ~cmp, MI.rv(~K, ~V, ~cmp, view)) == MI.rvp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.view_last_entry(~K, ~V, ~cmp, view)) : M.View<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
  view_extreme_s(~K, ~V, ~cmp, view, False{}, g_view)


def insert_side_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +z: Nat, +p: Nat, +g: Nat, +pn: M.Node<K>, +gn: M.Node<K>, +on_left: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.Fix, MI.insert_side(~K, ~V, ~cmp, m, z, p, g, pn, gn, on_left)) == True{} : Bool}:
  match on_left:
    case True{}:
      insert_side_left_g(~K, ~V, ~cmp, m, z, p, g, pn, gn, g_m)
    case False{}:
      insert_side_right_g(~K, ~V, ~cmp, m, z, p, g, pn, gn, g_m)

def insert_side_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +z: Nat, +p: Nat, +g: Nat, +pn: M.Node<K>, +gn: M.Node<K>, +on_left: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.insert_side(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), z, p, g, pn, gn, on_left) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_side(~K, ~V, ~cmp, m, z, p, g, pn, gn, on_left)) : M.TreeMap<K, V, cmp> & M.Fix}:
  match on_left:
    case True{}:
      insert_side_left_s(~K, ~V, ~cmp, m, z, p, g, pn, gn, g_m)
    case False{}:
      insert_side_right_s(~K, ~V, ~cmp, m, z, p, g, pn, gn, g_m)


def delete_far_left_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +w: Nat, +pn: M.Node<K>, +wn: M.Node<K>, +far_red: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_far_left(~K, ~V, ~cmp, m, p, w, pn, wn, far_red)) == True{} : Bool}:
  match far_red:
    case True{}:
      delete_borrow_left_g(~K, ~V, ~cmp, m, p, w, pn, wn, g_m)
    case False{}:
      delete_borrow_read_left_g(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_left(~K, wn), False{}), w, True{}), w), p, rotate_right_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_left(~K, wn), False{}), w, True{}), w, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_left(~K, wn), False{}), w, True{}, set_red_g(~K, ~V, ~cmp, m, M.node_left(~K, wn), False{}, g_m))))

def delete_far_left_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +w: Nat, +pn: M.Node<K>, +wn: M.Node<K>, +far_red: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.delete_far_left(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p, w, pn, wn, far_red) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_far_left(~K, ~V, ~cmp, m, p, w, pn, wn, far_red)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
  match far_red:
    case True{}:
      delete_borrow_left_s(~K, ~V, ~cmp, m, p, w, pn, wn, g_m)
    case False{}:
      %Equal.sym(M.TreeMap<K, V, cmp>, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), M.node_left(~K, wn), False{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_left(~K, wn), False{})), set_red_s(~K, ~V, ~cmp, m, M.node_left(~K, wn), False{}, g_m)) : {M.delete_borrow_read_left(~K, ~V, ~cmp, M.rotate_right(~K, ~V, ~cmp, M.set_red(~K, ~V, ~cmp, _, w, True{}), w), p) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_far_left(~K, ~V, ~cmp, m, p, w, pn, wn, False{})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
      %Equal.sym(M.TreeMap<K, V, cmp>, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_left(~K, wn), False{})), w, True{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_left(~K, wn), False{}), w, True{})), set_red_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_left(~K, wn), False{}), w, True{}, set_red_g(~K, ~V, ~cmp, m, M.node_left(~K, wn), False{}, g_m))) : {M.delete_borrow_read_left(~K, ~V, ~cmp, M.rotate_right(~K, ~V, ~cmp, _, w), p) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_far_left(~K, ~V, ~cmp, m, p, w, pn, wn, False{})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
      %Equal.sym(M.TreeMap<K, V, cmp>, M.rotate_right(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_left(~K, wn), False{}), w, True{})), w), ST.real(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_left(~K, wn), False{}), w, True{}), w)), rotate_right_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_left(~K, wn), False{}), w, True{}), w, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_left(~K, wn), False{}), w, True{}, set_red_g(~K, ~V, ~cmp, m, M.node_left(~K, wn), False{}, g_m)))) : {M.delete_borrow_read_left(~K, ~V, ~cmp, _, p) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_far_left(~K, ~V, ~cmp, m, p, w, pn, wn, False{})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
      delete_borrow_read_left_s(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_left(~K, wn), False{}), w, True{}), w), p, rotate_right_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_left(~K, wn), False{}), w, True{}), w, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_left(~K, wn), False{}), w, True{}, set_red_g(~K, ~V, ~cmp, m, M.node_left(~K, wn), False{}, g_m))))


def delete_far_right_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +w: Nat, +pn: M.Node<K>, +wn: M.Node<K>, +far_red: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_far_right(~K, ~V, ~cmp, m, p, w, pn, wn, far_red)) == True{} : Bool}:
  match far_red:
    case True{}:
      delete_borrow_right_g(~K, ~V, ~cmp, m, p, w, pn, wn, g_m)
    case False{}:
      delete_borrow_read_right_g(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_right(~K, wn), False{}), w, True{}), w), p, rotate_left_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_right(~K, wn), False{}), w, True{}), w, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_right(~K, wn), False{}), w, True{}, set_red_g(~K, ~V, ~cmp, m, M.node_right(~K, wn), False{}, g_m))))

def delete_far_right_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +w: Nat, +pn: M.Node<K>, +wn: M.Node<K>, +far_red: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.delete_far_right(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p, w, pn, wn, far_red) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_far_right(~K, ~V, ~cmp, m, p, w, pn, wn, far_red)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
  match far_red:
    case True{}:
      delete_borrow_right_s(~K, ~V, ~cmp, m, p, w, pn, wn, g_m)
    case False{}:
      %Equal.sym(M.TreeMap<K, V, cmp>, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), M.node_right(~K, wn), False{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_right(~K, wn), False{})), set_red_s(~K, ~V, ~cmp, m, M.node_right(~K, wn), False{}, g_m)) : {M.delete_borrow_read_right(~K, ~V, ~cmp, M.rotate_left(~K, ~V, ~cmp, M.set_red(~K, ~V, ~cmp, _, w, True{}), w), p) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_far_right(~K, ~V, ~cmp, m, p, w, pn, wn, False{})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
      %Equal.sym(M.TreeMap<K, V, cmp>, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_right(~K, wn), False{})), w, True{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_right(~K, wn), False{}), w, True{})), set_red_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_right(~K, wn), False{}), w, True{}, set_red_g(~K, ~V, ~cmp, m, M.node_right(~K, wn), False{}, g_m))) : {M.delete_borrow_read_right(~K, ~V, ~cmp, M.rotate_left(~K, ~V, ~cmp, _, w), p) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_far_right(~K, ~V, ~cmp, m, p, w, pn, wn, False{})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
      %Equal.sym(M.TreeMap<K, V, cmp>, M.rotate_left(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_right(~K, wn), False{}), w, True{})), w), ST.real(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_right(~K, wn), False{}), w, True{}), w)), rotate_left_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_right(~K, wn), False{}), w, True{}), w, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_right(~K, wn), False{}), w, True{}, set_red_g(~K, ~V, ~cmp, m, M.node_right(~K, wn), False{}, g_m)))) : {M.delete_borrow_read_right(~K, ~V, ~cmp, _, p) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_far_right(~K, ~V, ~cmp, m, p, w, pn, wn, False{})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
      delete_borrow_read_right_s(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_right(~K, wn), False{}), w, True{}), w), p, rotate_left_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_right(~K, wn), False{}), w, True{}), w, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, M.node_right(~K, wn), False{}), w, True{}, set_red_g(~K, ~V, ~cmp, m, M.node_right(~K, wn), False{}, g_m))))


def iterator_next_key_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +cursor: MI.MCursor<K, V>, +g_cursor: {MI.dgc(K, V, cursor) == True{} : Bool}) -> {MI.dgcp(K, V, Maybe<&2, K>, MI.iterator_next_key(~K, ~V, ~cmp, cursor)) == True{} : Bool}:
  iterator_key_result_g(~K, ~V, ~cmp, MI.iterator_next(~K, ~V, ~cmp, cursor), iterator_next_g(~K, ~V, ~cmp, cursor, g_cursor))

def iterator_next_key_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +cursor: MI.MCursor<K, V>, +g_cursor: {MI.dgc(K, V, cursor) == True{} : Bool}) -> {M.iterator_next_key(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, cursor)) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, K>, MI.iterator_next_key(~K, ~V, ~cmp, cursor)) : M.Cursor<K, V, cmp> & Maybe<&2, K>}:
  %Equal.sym(M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>, M.iterator_next(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, cursor)), MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.iterator_next(~K, ~V, ~cmp, cursor)), iterator_next_s(~K, ~V, ~cmp, cursor, g_cursor)) : {M.iterator_key_result(~K, ~V, ~cmp, _) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, K>, MI.iterator_next_key(~K, ~V, ~cmp, cursor)) : M.Cursor<K, V, cmp> & Maybe<&2, K>}
  iterator_key_result_s(~K, ~V, ~cmp, MI.iterator_next(~K, ~V, ~cmp, cursor), iterator_next_g(~K, ~V, ~cmp, cursor, g_cursor))


def iterator_next_value_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +cursor: MI.MCursor<K, V>, +g_cursor: {MI.dgc(K, V, cursor) == True{} : Bool}) -> {MI.dgcp(K, V, Maybe<&2, V>, MI.iterator_next_value(~K, ~V, ~cmp, cursor)) == True{} : Bool}:
  iterator_value_result_g(~K, ~V, ~cmp, MI.iterator_next(~K, ~V, ~cmp, cursor), iterator_next_g(~K, ~V, ~cmp, cursor, g_cursor))

def iterator_next_value_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +cursor: MI.MCursor<K, V>, +g_cursor: {MI.dgc(K, V, cursor) == True{} : Bool}) -> {M.iterator_next_value(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, cursor)) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, V>, MI.iterator_next_value(~K, ~V, ~cmp, cursor)) : M.Cursor<K, V, cmp> & Maybe<&2, V>}:
  %Equal.sym(M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>, M.iterator_next(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, cursor)), MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.iterator_next(~K, ~V, ~cmp, cursor)), iterator_next_s(~K, ~V, ~cmp, cursor, g_cursor)) : {M.iterator_value_result(~K, ~V, ~cmp, _) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, V>, MI.iterator_next_value(~K, ~V, ~cmp, cursor)) : M.Cursor<K, V, cmp> & Maybe<&2, V>}
  iterator_value_result_s(~K, ~V, ~cmp, MI.iterator_next(~K, ~V, ~cmp, cursor), iterator_next_g(~K, ~V, ~cmp, cursor, g_cursor))


def contains_value_loop_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~eq: V -> V -> Bool, +fuel: Nat, +wanted: V, +found: Bool, st: MI.MCursor<K, V> & Maybe<&2, M.Entry<K, V>>, +g_st: {MI.dgcp(K, V, Maybe<&2, M.Entry<K, V>>, st) == True{} : Bool}) -> {MI.dgp(K, V, Bool, MI.contains_value_loop(~K, ~V, ~cmp, ~eq, fuel, wanted, found, st)) == True{} : Bool}:
  match fuel found st:
    case 0n True{} Tuple{+px4, None{}}:
      iterator_finish_g(~K, ~V, ~cmp, px4, g_st)
    case 0n True{} Tuple{+px4, Some{+px7}}:
      iterator_finish_g(~K, ~V, ~cmp, px4, g_st)
    case 1n+ +px6 True{} Tuple{+px4, None{}}:
      iterator_finish_g(~K, ~V, ~cmp, px4, g_st)
    case 1n+ +px6 True{} Tuple{+px4, Some{+px7}}:
      iterator_finish_g(~K, ~V, ~cmp, px4, g_st)
    case 0n False{} Tuple{+px9, None{}}:
      iterator_finish_g(~K, ~V, ~cmp, px9, g_st)
    case 0n False{} Tuple{+px9, Some{+px11}}:
      iterator_finish_g(~K, ~V, ~cmp, px9, g_st)
    case 1n+ +px8 False{} Tuple{+px12, None{}}:
      iterator_finish_g(~K, ~V, ~cmp, px12, g_st)
    case 1n+ +px8 False{} Tuple{+px12, Some{M.Entry{+px15, +px16}}}:
      contains_value_loop_g(~K, ~V, ~cmp, ~eq, px8, wanted, eq(px16, wanted), MI.iterator_next(~K, ~V, ~cmp, px12), iterator_next_g(~K, ~V, ~cmp, px12, g_st))

def contains_value_loop_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~eq: V -> V -> Bool, +fuel: Nat, +wanted: V, +found: Bool, st: MI.MCursor<K, V> & Maybe<&2, M.Entry<K, V>>, +g_st: {MI.dgcp(K, V, Maybe<&2, M.Entry<K, V>>, st) == True{} : Bool}) -> {M.contains_value_loop(~K, ~V, ~cmp, ~eq, fuel, wanted, found, MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, st)) == MI.rp(~K, ~V, ~cmp, Bool, MI.contains_value_loop(~K, ~V, ~cmp, ~eq, fuel, wanted, found, st)) : M.TreeMap<K, V, cmp> & Bool}:
  match fuel found st:
    case 0n True{} Tuple{+px4, None{}}:
      %Equal.sym(M.TreeMap<K, V, cmp>, M.iterator_finish(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, px4)), ST.real(~K, ~V, ~cmp, MI.iterator_finish(~K, ~V, ~cmp, px4)), iterator_finish_s(~K, ~V, ~cmp, px4, g_st)) : {(_, True{}) == MI.rp(~K, ~V, ~cmp, Bool, MI.contains_value_loop(~K, ~V, ~cmp, ~eq, 0n, wanted, True{}, Tuple{px4, None{}})) : M.TreeMap<K, V, cmp> & Bool}
      {==}
    case 0n True{} Tuple{+px4, Some{+px7}}:
      %Equal.sym(M.TreeMap<K, V, cmp>, M.iterator_finish(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, px4)), ST.real(~K, ~V, ~cmp, MI.iterator_finish(~K, ~V, ~cmp, px4)), iterator_finish_s(~K, ~V, ~cmp, px4, g_st)) : {(_, True{}) == MI.rp(~K, ~V, ~cmp, Bool, MI.contains_value_loop(~K, ~V, ~cmp, ~eq, 0n, wanted, True{}, Tuple{px4, Some{px7}})) : M.TreeMap<K, V, cmp> & Bool}
      {==}
    case 1n+ +px6 True{} Tuple{+px4, None{}}:
      %Equal.sym(M.TreeMap<K, V, cmp>, M.iterator_finish(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, px4)), ST.real(~K, ~V, ~cmp, MI.iterator_finish(~K, ~V, ~cmp, px4)), iterator_finish_s(~K, ~V, ~cmp, px4, g_st)) : {(_, True{}) == MI.rp(~K, ~V, ~cmp, Bool, MI.contains_value_loop(~K, ~V, ~cmp, ~eq, 1n+ px6, wanted, True{}, Tuple{px4, None{}})) : M.TreeMap<K, V, cmp> & Bool}
      {==}
    case 1n+ +px6 True{} Tuple{+px4, Some{+px7}}:
      %Equal.sym(M.TreeMap<K, V, cmp>, M.iterator_finish(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, px4)), ST.real(~K, ~V, ~cmp, MI.iterator_finish(~K, ~V, ~cmp, px4)), iterator_finish_s(~K, ~V, ~cmp, px4, g_st)) : {(_, True{}) == MI.rp(~K, ~V, ~cmp, Bool, MI.contains_value_loop(~K, ~V, ~cmp, ~eq, 1n+ px6, wanted, True{}, Tuple{px4, Some{px7}})) : M.TreeMap<K, V, cmp> & Bool}
      {==}
    case 0n False{} Tuple{+px9, None{}}:
      %Equal.sym(M.TreeMap<K, V, cmp>, M.iterator_finish(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, px9)), ST.real(~K, ~V, ~cmp, MI.iterator_finish(~K, ~V, ~cmp, px9)), iterator_finish_s(~K, ~V, ~cmp, px9, g_st)) : {(_, False{}) == MI.rp(~K, ~V, ~cmp, Bool, MI.contains_value_loop(~K, ~V, ~cmp, ~eq, 0n, wanted, False{}, Tuple{px9, None{}})) : M.TreeMap<K, V, cmp> & Bool}
      {==}
    case 0n False{} Tuple{+px9, Some{+px11}}:
      %Equal.sym(M.TreeMap<K, V, cmp>, M.iterator_finish(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, px9)), ST.real(~K, ~V, ~cmp, MI.iterator_finish(~K, ~V, ~cmp, px9)), iterator_finish_s(~K, ~V, ~cmp, px9, g_st)) : {(_, False{}) == MI.rp(~K, ~V, ~cmp, Bool, MI.contains_value_loop(~K, ~V, ~cmp, ~eq, 0n, wanted, False{}, Tuple{px9, Some{px11}})) : M.TreeMap<K, V, cmp> & Bool}
      {==}
    case 1n+ +px8 False{} Tuple{+px12, None{}}:
      %Equal.sym(M.TreeMap<K, V, cmp>, M.iterator_finish(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, px12)), ST.real(~K, ~V, ~cmp, MI.iterator_finish(~K, ~V, ~cmp, px12)), iterator_finish_s(~K, ~V, ~cmp, px12, g_st)) : {(_, False{}) == MI.rp(~K, ~V, ~cmp, Bool, MI.contains_value_loop(~K, ~V, ~cmp, ~eq, 1n+ px8, wanted, False{}, Tuple{px12, None{}})) : M.TreeMap<K, V, cmp> & Bool}
      {==}
    case 1n+ +px8 False{} Tuple{+px12, Some{M.Entry{+px15, +px16}}}:
      %Equal.sym(M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>, M.iterator_next(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, px12)), MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.iterator_next(~K, ~V, ~cmp, px12)), iterator_next_s(~K, ~V, ~cmp, px12, g_st)) : {M.contains_value_loop(~K, ~V, ~cmp, ~eq, px8, wanted, eq(px16, wanted), _) == MI.rp(~K, ~V, ~cmp, Bool, MI.contains_value_loop(~K, ~V, ~cmp, ~eq, 1n+ px8, wanted, False{}, Tuple{px12, Some{M.Entry{px15, px16}}})) : M.TreeMap<K, V, cmp> & Bool}
      contains_value_loop_s(~K, ~V, ~cmp, ~eq, px8, wanted, eq(px16, wanted), MI.iterator_next(~K, ~V, ~cmp, px12), iterator_next_g(~K, ~V, ~cmp, px12, g_st))


def view_lower_entry_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +k: K, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {MI.dgvp(K, V, Maybe<&2, M.Entry<K, V>>, MI.view_lower_entry(~K, ~V, ~cmp, view, k)) == True{} : Bool}:
  view_nav_g(~K, ~V, ~cmp, view, k, False{}, False{}, g_view)

def view_lower_entry_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +k: K, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {M.view_lower_entry(~K, ~V, ~cmp, MI.rv(~K, ~V, ~cmp, view), k) == MI.rvp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.view_lower_entry(~K, ~V, ~cmp, view, k)) : M.View<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
  view_nav_s(~K, ~V, ~cmp, view, k, False{}, False{}, g_view)


def view_floor_entry_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +k: K, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {MI.dgvp(K, V, Maybe<&2, M.Entry<K, V>>, MI.view_floor_entry(~K, ~V, ~cmp, view, k)) == True{} : Bool}:
  view_nav_g(~K, ~V, ~cmp, view, k, False{}, True{}, g_view)

def view_floor_entry_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +k: K, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {M.view_floor_entry(~K, ~V, ~cmp, MI.rv(~K, ~V, ~cmp, view), k) == MI.rvp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.view_floor_entry(~K, ~V, ~cmp, view, k)) : M.View<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
  view_nav_s(~K, ~V, ~cmp, view, k, False{}, True{}, g_view)


def view_ceiling_entry_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +k: K, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {MI.dgvp(K, V, Maybe<&2, M.Entry<K, V>>, MI.view_ceiling_entry(~K, ~V, ~cmp, view, k)) == True{} : Bool}:
  view_nav_g(~K, ~V, ~cmp, view, k, True{}, True{}, g_view)

def view_ceiling_entry_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +k: K, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {M.view_ceiling_entry(~K, ~V, ~cmp, MI.rv(~K, ~V, ~cmp, view), k) == MI.rvp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.view_ceiling_entry(~K, ~V, ~cmp, view, k)) : M.View<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
  view_nav_s(~K, ~V, ~cmp, view, k, True{}, True{}, g_view)


def view_higher_entry_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +k: K, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {MI.dgvp(K, V, Maybe<&2, M.Entry<K, V>>, MI.view_higher_entry(~K, ~V, ~cmp, view, k)) == True{} : Bool}:
  view_nav_g(~K, ~V, ~cmp, view, k, True{}, False{}, g_view)

def view_higher_entry_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +k: K, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {M.view_higher_entry(~K, ~V, ~cmp, MI.rv(~K, ~V, ~cmp, view), k) == MI.rvp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.view_higher_entry(~K, ~V, ~cmp, view, k)) : M.View<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
  view_nav_s(~K, ~V, ~cmp, view, k, True{}, False{}, g_view)


def view_count_loop_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +fuel: Nat, +count: Nat, st: MI.MCursor<K, V> & Maybe<&2, M.Entry<K, V>>, +g_st: {MI.dgcp(K, V, Maybe<&2, M.Entry<K, V>>, st) == True{} : Bool}) -> {MI.dgvp(K, V, Nat, MI.view_count_loop(~K, ~V, ~cmp, fuel, count, st)) == True{} : Bool}:
  match fuel st:
    case 0n Tuple{+px4, None{}}:
      iterator_view_g(~K, ~V, ~cmp, px4, g_st)
    case 0n Tuple{+px4, Some{+px6}}:
      iterator_view_g(~K, ~V, ~cmp, px4, g_st)
    case 1n+ +px3 Tuple{+px7, None{}}:
      iterator_view_g(~K, ~V, ~cmp, px7, g_st)
    case 1n+ +px3 Tuple{+px7, Some{+px9}}:
      view_count_loop_g(~K, ~V, ~cmp, px3, 1n+count, MI.iterator_next(~K, ~V, ~cmp, px7), iterator_next_g(~K, ~V, ~cmp, px7, g_st))

def view_count_loop_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +fuel: Nat, +count: Nat, st: MI.MCursor<K, V> & Maybe<&2, M.Entry<K, V>>, +g_st: {MI.dgcp(K, V, Maybe<&2, M.Entry<K, V>>, st) == True{} : Bool}) -> {M.view_count_loop(~K, ~V, ~cmp, fuel, count, MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, st)) == MI.rvp(~K, ~V, ~cmp, Nat, MI.view_count_loop(~K, ~V, ~cmp, fuel, count, st)) : M.View<K, V, cmp> & Nat}:
  match fuel st:
    case 0n Tuple{+px4, None{}}:
      %Equal.sym(M.View<K, V, cmp>, M.iterator_view(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, px4)), MI.rv(~K, ~V, ~cmp, MI.iterator_view(~K, ~V, ~cmp, px4)), iterator_view_s(~K, ~V, ~cmp, px4, g_st)) : {(_, count) == MI.rvp(~K, ~V, ~cmp, Nat, MI.view_count_loop(~K, ~V, ~cmp, 0n, count, Tuple{px4, None{}})) : M.View<K, V, cmp> & Nat}
      {==}
    case 0n Tuple{+px4, Some{+px6}}:
      %Equal.sym(M.View<K, V, cmp>, M.iterator_view(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, px4)), MI.rv(~K, ~V, ~cmp, MI.iterator_view(~K, ~V, ~cmp, px4)), iterator_view_s(~K, ~V, ~cmp, px4, g_st)) : {(_, count) == MI.rvp(~K, ~V, ~cmp, Nat, MI.view_count_loop(~K, ~V, ~cmp, 0n, count, Tuple{px4, Some{px6}})) : M.View<K, V, cmp> & Nat}
      {==}
    case 1n+ +px3 Tuple{+px7, None{}}:
      %Equal.sym(M.View<K, V, cmp>, M.iterator_view(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, px7)), MI.rv(~K, ~V, ~cmp, MI.iterator_view(~K, ~V, ~cmp, px7)), iterator_view_s(~K, ~V, ~cmp, px7, g_st)) : {(_, count) == MI.rvp(~K, ~V, ~cmp, Nat, MI.view_count_loop(~K, ~V, ~cmp, 1n+ px3, count, Tuple{px7, None{}})) : M.View<K, V, cmp> & Nat}
      {==}
    case 1n+ +px3 Tuple{+px7, Some{+px9}}:
      %Equal.sym(M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>, M.iterator_next(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, px7)), MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.iterator_next(~K, ~V, ~cmp, px7)), iterator_next_s(~K, ~V, ~cmp, px7, g_st)) : {M.view_count_loop(~K, ~V, ~cmp, px3, 1n+count, _) == MI.rvp(~K, ~V, ~cmp, Nat, MI.view_count_loop(~K, ~V, ~cmp, 1n+ px3, count, Tuple{px7, Some{px9}})) : M.View<K, V, cmp> & Nat}
      view_count_loop_s(~K, ~V, ~cmp, px3, 1n+count, MI.iterator_next(~K, ~V, ~cmp, px7), iterator_next_g(~K, ~V, ~cmp, px7, g_st))


def view_clear_next_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: MI.MCursor<K, V> & Maybe<&2, V>, +g_r: {MI.dgcp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {MI.dgcp(K, V, Maybe<&2, M.Entry<K, V>>, MI.view_clear_next(~K, ~V, ~cmp, r)) == True{} : Bool}:
  match r:
    case Tuple{+cursor, +removed}:
      iterator_next_g(~K, ~V, ~cmp, cursor, g_r)

def view_clear_next_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: MI.MCursor<K, V> & Maybe<&2, V>, +g_r: {MI.dgcp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {M.view_clear_next(~K, ~V, ~cmp, MI.rcp(~K, ~V, ~cmp, Maybe<&2, V>, r)) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.view_clear_next(~K, ~V, ~cmp, r)) : M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
  match r:
    case Tuple{+cursor, +removed}:
      iterator_next_s(~K, ~V, ~cmp, cursor, g_r)


def insert_grand_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +z: Nat, +p: Nat, +pn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.Fix, MI.insert_grand_1(~K, ~V, ~cmp, z, p, pn, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m1, +gn}:
      insert_side_g(~K, ~V, ~cmp, m1, z, p, M.node_parent(~K, pn), pn, gn, Nat.is_eq(p, M.node_left(~K, gn)), g_pair_result)

def insert_grand_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +z: Nat, +p: Nat, +pn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.insert_grand_1(~K, ~V, ~cmp, z, p, pn, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_grand_1(~K, ~V, ~cmp, z, p, pn, pair_result)) : M.TreeMap<K, V, cmp> & M.Fix}:
  match pair_result:
    case Tuple{+m1, +gn}:
      insert_side_s(~K, ~V, ~cmp, m1, z, p, M.node_parent(~K, pn), pn, gn, Nat.is_eq(p, M.node_left(~K, gn)), g_pair_result)


def delete_children_left_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +w: Nat, +pn: M.Node<K>, +wn: M.Node<K>, +near_red: Bool, +far_red: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_children_left(~K, ~V, ~cmp, m, p, w, pn, wn, near_red, far_red)) == True{} : Bool}:
  match near_red far_red:
    case False{} False{}:
      set_red_g(~K, ~V, ~cmp, m, w, True{}, g_m)
    case True{} True{}:
      delete_far_left_g(~K, ~V, ~cmp, m, p, w, pn, wn, far_red, g_m)
    case True{} False{}:
      delete_far_left_g(~K, ~V, ~cmp, m, p, w, pn, wn, far_red, g_m)
    case False{} True{}:
      delete_far_left_g(~K, ~V, ~cmp, m, p, w, pn, wn, far_red, g_m)

def delete_children_left_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +w: Nat, +pn: M.Node<K>, +wn: M.Node<K>, +near_red: Bool, +far_red: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.delete_children_left(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p, w, pn, wn, near_red, far_red) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_children_left(~K, ~V, ~cmp, m, p, w, pn, wn, near_red, far_red)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
  match near_red far_red:
    case False{} False{}:
      %Equal.sym(M.TreeMap<K, V, cmp>, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), w, True{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, True{})), set_red_s(~K, ~V, ~cmp, m, w, True{}, g_m)) : {(_, M.DF{p, M.node_parent(~K, pn), True{}}) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_children_left(~K, ~V, ~cmp, m, p, w, pn, wn, False{}, False{})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
      {==}
    case True{} True{}:
      delete_far_left_s(~K, ~V, ~cmp, m, p, w, pn, wn, far_red, g_m)
    case True{} False{}:
      delete_far_left_s(~K, ~V, ~cmp, m, p, w, pn, wn, far_red, g_m)
    case False{} True{}:
      delete_far_left_s(~K, ~V, ~cmp, m, p, w, pn, wn, far_red, g_m)


def delete_children_right_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +w: Nat, +pn: M.Node<K>, +wn: M.Node<K>, +near_red: Bool, +far_red: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_children_right(~K, ~V, ~cmp, m, p, w, pn, wn, near_red, far_red)) == True{} : Bool}:
  match near_red far_red:
    case False{} False{}:
      set_red_g(~K, ~V, ~cmp, m, w, True{}, g_m)
    case True{} True{}:
      delete_far_right_g(~K, ~V, ~cmp, m, p, w, pn, wn, far_red, g_m)
    case True{} False{}:
      delete_far_right_g(~K, ~V, ~cmp, m, p, w, pn, wn, far_red, g_m)
    case False{} True{}:
      delete_far_right_g(~K, ~V, ~cmp, m, p, w, pn, wn, far_red, g_m)

def delete_children_right_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +w: Nat, +pn: M.Node<K>, +wn: M.Node<K>, +near_red: Bool, +far_red: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.delete_children_right(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p, w, pn, wn, near_red, far_red) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_children_right(~K, ~V, ~cmp, m, p, w, pn, wn, near_red, far_red)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
  match near_red far_red:
    case False{} False{}:
      %Equal.sym(M.TreeMap<K, V, cmp>, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), w, True{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, True{})), set_red_s(~K, ~V, ~cmp, m, w, True{}, g_m)) : {(_, M.DF{p, M.node_parent(~K, pn), True{}}) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_children_right(~K, ~V, ~cmp, m, p, w, pn, wn, False{}, False{})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
      {==}
    case True{} True{}:
      delete_far_right_s(~K, ~V, ~cmp, m, p, w, pn, wn, far_red, g_m)
    case True{} False{}:
      delete_far_right_s(~K, ~V, ~cmp, m, p, w, pn, wn, far_red, g_m)
    case False{} True{}:
      delete_far_right_s(~K, ~V, ~cmp, m, p, w, pn, wn, far_red, g_m)


def contains_value_start_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~eq: V -> V -> Bool, +wanted: V, r: ST.Sh<K, V> & Nat, +g_r: {MI.dgp(K, V, Nat, r) == True{} : Bool}) -> {MI.dgp(K, V, Bool, MI.contains_value_start(~K, ~V, ~cmp, ~eq, wanted, r)) == True{} : Bool}:
  match r:
    case Tuple{+m, +n}:
      contains_value_loop_g(~K, ~V, ~cmp, ~eq, 1n+n, wanted, False{}, MI.iterator_next(~K, ~V, ~cmp, MI.iterator(~K, ~V, ~cmp, m)), iterator_next_g(~K, ~V, ~cmp, MI.iterator(~K, ~V, ~cmp, m), iterator_g(~K, ~V, ~cmp, m, g_r)))

def contains_value_start_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~eq: V -> V -> Bool, +wanted: V, r: ST.Sh<K, V> & Nat, +g_r: {MI.dgp(K, V, Nat, r) == True{} : Bool}) -> {M.contains_value_start(~K, ~V, ~cmp, ~eq, wanted, MI.rp(~K, ~V, ~cmp, Nat, r)) == MI.rp(~K, ~V, ~cmp, Bool, MI.contains_value_start(~K, ~V, ~cmp, ~eq, wanted, r)) : M.TreeMap<K, V, cmp> & Bool}:
  match r:
    case Tuple{+m, +n}:
      %Equal.sym(M.Cursor<K, V, cmp>, M.iterator(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)), MI.rc(~K, ~V, ~cmp, MI.iterator(~K, ~V, ~cmp, m)), iterator_s(~K, ~V, ~cmp, m, g_r)) : {M.contains_value_loop(~K, ~V, ~cmp, ~eq, 1n+n, wanted, False{}, M.iterator_next(~K, ~V, ~cmp, _)) == MI.rp(~K, ~V, ~cmp, Bool, MI.contains_value_start(~K, ~V, ~cmp, ~eq, wanted, Tuple{m, n})) : M.TreeMap<K, V, cmp> & Bool}
      %Equal.sym(M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>, M.iterator_next(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, MI.iterator(~K, ~V, ~cmp, m))), MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.iterator_next(~K, ~V, ~cmp, MI.iterator(~K, ~V, ~cmp, m))), iterator_next_s(~K, ~V, ~cmp, MI.iterator(~K, ~V, ~cmp, m), iterator_g(~K, ~V, ~cmp, m, g_r))) : {M.contains_value_loop(~K, ~V, ~cmp, ~eq, 1n+n, wanted, False{}, _) == MI.rp(~K, ~V, ~cmp, Bool, MI.contains_value_start(~K, ~V, ~cmp, ~eq, wanted, Tuple{m, n})) : M.TreeMap<K, V, cmp> & Bool}
      contains_value_loop_s(~K, ~V, ~cmp, ~eq, 1n+n, wanted, False{}, MI.iterator_next(~K, ~V, ~cmp, MI.iterator(~K, ~V, ~cmp, m)), iterator_next_g(~K, ~V, ~cmp, MI.iterator(~K, ~V, ~cmp, m), iterator_g(~K, ~V, ~cmp, m, g_r)))


def view_size_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {MI.dgvp(K, V, Nat, MI.view_size(~K, ~V, ~cmp, view)) == True{} : Bool}:
  match view:
    case MI.MV{ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}, +lower, +upper, +descending}:
      view_count_loop_g(~K, ~V, ~cmp, 1n+n, 0n, MI.iterator_next(~K, ~V, ~cmp, MI.view_iterator(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending})), iterator_next_g(~K, ~V, ~cmp, MI.view_iterator(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending}), view_iterator_g(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending}, g_view)))

def view_size_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {M.view_size(~K, ~V, ~cmp, MI.rv(~K, ~V, ~cmp, view)) == MI.rvp(~K, ~V, ~cmp, Nat, MI.view_size(~K, ~V, ~cmp, view)) : M.View<K, V, cmp> & Nat}:
  match view:
    case MI.MV{ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}, +lower, +upper, +descending}:
      %Equal.sym(M.Cursor<K, V, cmp>, M.view_iterator(~K, ~V, ~cmp, M.View{ST.real(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}), lower, upper, descending}), MI.rc(~K, ~V, ~cmp, MI.view_iterator(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending})), view_iterator_s(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending}, g_view)) : {M.view_count_loop(~K, ~V, ~cmp, 1n+n, 0n, M.iterator_next(~K, ~V, ~cmp, _)) == MI.rvp(~K, ~V, ~cmp, Nat, MI.view_size(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending})) : M.View<K, V, cmp> & Nat}
      %Equal.sym(M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>, M.iterator_next(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, MI.view_iterator(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending}))), MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.iterator_next(~K, ~V, ~cmp, MI.view_iterator(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending}))), iterator_next_s(~K, ~V, ~cmp, MI.view_iterator(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending}), view_iterator_g(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending}, g_view))) : {M.view_count_loop(~K, ~V, ~cmp, 1n+n, 0n, _) == MI.rvp(~K, ~V, ~cmp, Nat, MI.view_size(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending})) : M.View<K, V, cmp> & Nat}
      view_count_loop_s(~K, ~V, ~cmp, 1n+n, 0n, MI.iterator_next(~K, ~V, ~cmp, MI.view_iterator(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending})), iterator_next_g(~K, ~V, ~cmp, MI.view_iterator(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending}), view_iterator_g(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending}, g_view)))


def insert_grand_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +z: Nat, +p: Nat, +pn: M.Node<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.Fix, MI.insert_grand(~K, ~V, ~cmp, m, z, p, pn)) == True{} : Bool}:
  insert_grand_1_g(~K, ~V, ~cmp, z, p, pn, MI.read(~K, ~V, ~cmp, m, M.node_parent(~K, pn)), read_g(~K, ~V, ~cmp, m, M.node_parent(~K, pn), g_m))

def insert_grand_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +z: Nat, +p: Nat, +pn: M.Node<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.insert_grand(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), z, p, pn) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_grand(~K, ~V, ~cmp, m, z, p, pn)) : M.TreeMap<K, V, cmp> & M.Fix}:
  %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), M.node_parent(~K, pn)), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m, M.node_parent(~K, pn))), read_s(~K, ~V, ~cmp, m, M.node_parent(~K, pn), g_m)) : {M.insert_grand_1(~K, ~V, ~cmp, z, p, pn, _) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_grand(~K, ~V, ~cmp, m, z, p, pn)) : M.TreeMap<K, V, cmp> & M.Fix}
  insert_grand_1_s(~K, ~V, ~cmp, z, p, pn, MI.read(~K, ~V, ~cmp, m, M.node_parent(~K, pn)), read_g(~K, ~V, ~cmp, m, M.node_parent(~K, pn), g_m))


def delete_sibling_left_4_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +pn: M.Node<K>, +wn: M.Node<K>, +near_node: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_sibling_left_4(~K, ~V, ~cmp, p, pn, wn, near_node, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m4, +far_node}:
      delete_children_left_g(~K, ~V, ~cmp, m4, p, M.node_right(~K, pn), pn, wn, M.node_red(~K, near_node), M.node_red(~K, far_node), g_pair_result)

def delete_sibling_left_4_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +pn: M.Node<K>, +wn: M.Node<K>, +near_node: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.delete_sibling_left_4(~K, ~V, ~cmp, p, pn, wn, near_node, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_sibling_left_4(~K, ~V, ~cmp, p, pn, wn, near_node, pair_result)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
  match pair_result:
    case Tuple{+m4, +far_node}:
      delete_children_left_s(~K, ~V, ~cmp, m4, p, M.node_right(~K, pn), pn, wn, M.node_red(~K, near_node), M.node_red(~K, far_node), g_pair_result)


def delete_sibling_right_4_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +pn: M.Node<K>, +wn: M.Node<K>, +near_node: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_sibling_right_4(~K, ~V, ~cmp, p, pn, wn, near_node, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m4, +far_node}:
      delete_children_right_g(~K, ~V, ~cmp, m4, p, M.node_left(~K, pn), pn, wn, M.node_red(~K, near_node), M.node_red(~K, far_node), g_pair_result)

def delete_sibling_right_4_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +pn: M.Node<K>, +wn: M.Node<K>, +near_node: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.delete_sibling_right_4(~K, ~V, ~cmp, p, pn, wn, near_node, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_sibling_right_4(~K, ~V, ~cmp, p, pn, wn, near_node, pair_result)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
  match pair_result:
    case Tuple{+m4, +far_node}:
      delete_children_right_s(~K, ~V, ~cmp, m4, p, M.node_left(~K, pn), pn, wn, M.node_red(~K, near_node), M.node_red(~K, far_node), g_pair_result)


def contains_value_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~eq: V -> V -> Bool, +m: ST.Sh<K, V>, +wanted: V, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Bool, MI.contains_value(~K, ~V, ~cmp, ~eq, m, wanted)) == True{} : Bool}:
  contains_value_start_g(~K, ~V, ~cmp, ~eq, wanted, MI.size(~K, ~V, ~cmp, m), size_g(~K, ~V, ~cmp, m, g_m))

def contains_value_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~eq: V -> V -> Bool, +m: ST.Sh<K, V>, +wanted: V, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.contains_value(~K, ~V, ~cmp, ~eq, ST.real(~K, ~V, ~cmp, m), wanted) == MI.rp(~K, ~V, ~cmp, Bool, MI.contains_value(~K, ~V, ~cmp, ~eq, m, wanted)) : M.TreeMap<K, V, cmp> & Bool}:
  %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.size(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)), MI.rp(~K, ~V, ~cmp, Nat, MI.size(~K, ~V, ~cmp, m)), size_s(~K, ~V, ~cmp, m, g_m)) : {M.contains_value_start(~K, ~V, ~cmp, ~eq, wanted, _) == MI.rp(~K, ~V, ~cmp, Bool, MI.contains_value(~K, ~V, ~cmp, ~eq, m, wanted)) : M.TreeMap<K, V, cmp> & Bool}
  contains_value_start_s(~K, ~V, ~cmp, ~eq, wanted, MI.size(~K, ~V, ~cmp, m), size_g(~K, ~V, ~cmp, m, g_m))


def insert_parent_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +z: Nat, +p: Nat, +pn: M.Node<K>, +is_red: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.Fix, MI.insert_parent(~K, ~V, ~cmp, m, z, p, pn, is_red)) == True{} : Bool}:
  match is_red:
    case False{}:
      g_m
    case True{}:
      insert_grand_g(~K, ~V, ~cmp, m, z, p, pn, g_m)

def insert_parent_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +z: Nat, +p: Nat, +pn: M.Node<K>, +is_red: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.insert_parent(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), z, p, pn, is_red) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_parent(~K, ~V, ~cmp, m, z, p, pn, is_red)) : M.TreeMap<K, V, cmp> & M.Fix}:
  match is_red:
    case False{}:
      {==}
    case True{}:
      insert_grand_s(~K, ~V, ~cmp, m, z, p, pn, g_m)


def delete_sibling_left_3_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +pn: M.Node<K>, +wn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_sibling_left_3(~K, ~V, ~cmp, p, pn, wn, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m3, +near_node}:
      delete_sibling_left_4_g(~K, ~V, ~cmp, p, pn, wn, near_node, MI.read(~K, ~V, ~cmp, m3, M.node_right(~K, wn)), read_g(~K, ~V, ~cmp, m3, M.node_right(~K, wn), g_pair_result))

def delete_sibling_left_3_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +pn: M.Node<K>, +wn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.delete_sibling_left_3(~K, ~V, ~cmp, p, pn, wn, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_sibling_left_3(~K, ~V, ~cmp, p, pn, wn, pair_result)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
  match pair_result:
    case Tuple{+m3, +near_node}:
      %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m3), M.node_right(~K, wn)), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m3, M.node_right(~K, wn))), read_s(~K, ~V, ~cmp, m3, M.node_right(~K, wn), g_pair_result)) : {M.delete_sibling_left_4(~K, ~V, ~cmp, p, pn, wn, near_node, _) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_sibling_left_3(~K, ~V, ~cmp, p, pn, wn, Tuple{m3, near_node})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
      delete_sibling_left_4_s(~K, ~V, ~cmp, p, pn, wn, near_node, MI.read(~K, ~V, ~cmp, m3, M.node_right(~K, wn)), read_g(~K, ~V, ~cmp, m3, M.node_right(~K, wn), g_pair_result))


def delete_sibling_right_3_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +pn: M.Node<K>, +wn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_sibling_right_3(~K, ~V, ~cmp, p, pn, wn, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m3, +near_node}:
      delete_sibling_right_4_g(~K, ~V, ~cmp, p, pn, wn, near_node, MI.read(~K, ~V, ~cmp, m3, M.node_left(~K, wn)), read_g(~K, ~V, ~cmp, m3, M.node_left(~K, wn), g_pair_result))

def delete_sibling_right_3_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +pn: M.Node<K>, +wn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.delete_sibling_right_3(~K, ~V, ~cmp, p, pn, wn, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_sibling_right_3(~K, ~V, ~cmp, p, pn, wn, pair_result)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
  match pair_result:
    case Tuple{+m3, +near_node}:
      %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m3), M.node_left(~K, wn)), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m3, M.node_left(~K, wn))), read_s(~K, ~V, ~cmp, m3, M.node_left(~K, wn), g_pair_result)) : {M.delete_sibling_right_4(~K, ~V, ~cmp, p, pn, wn, near_node, _) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_sibling_right_3(~K, ~V, ~cmp, p, pn, wn, Tuple{m3, near_node})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
      delete_sibling_right_4_s(~K, ~V, ~cmp, p, pn, wn, near_node, MI.read(~K, ~V, ~cmp, m3, M.node_left(~K, wn)), read_g(~K, ~V, ~cmp, m3, M.node_left(~K, wn), g_pair_result))


def insert_fix_step_2_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +z: Nat, +zn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.Fix, MI.insert_fix_step_2(~K, ~V, ~cmp, z, zn, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m2, +pn}:
      insert_parent_g(~K, ~V, ~cmp, m2, z, M.node_parent(~K, zn), pn, M.node_red(~K, pn), g_pair_result)

def insert_fix_step_2_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +z: Nat, +zn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.insert_fix_step_2(~K, ~V, ~cmp, z, zn, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_fix_step_2(~K, ~V, ~cmp, z, zn, pair_result)) : M.TreeMap<K, V, cmp> & M.Fix}:
  match pair_result:
    case Tuple{+m2, +pn}:
      insert_parent_s(~K, ~V, ~cmp, m2, z, M.node_parent(~K, zn), pn, M.node_red(~K, pn), g_pair_result)


def delete_sibling_left_2_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +pn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_sibling_left_2(~K, ~V, ~cmp, p, pn, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m2, +wn}:
      delete_sibling_left_3_g(~K, ~V, ~cmp, p, pn, wn, MI.read(~K, ~V, ~cmp, m2, M.node_left(~K, wn)), read_g(~K, ~V, ~cmp, m2, M.node_left(~K, wn), g_pair_result))

def delete_sibling_left_2_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +pn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.delete_sibling_left_2(~K, ~V, ~cmp, p, pn, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_sibling_left_2(~K, ~V, ~cmp, p, pn, pair_result)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
  match pair_result:
    case Tuple{+m2, +wn}:
      %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m2), M.node_left(~K, wn)), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m2, M.node_left(~K, wn))), read_s(~K, ~V, ~cmp, m2, M.node_left(~K, wn), g_pair_result)) : {M.delete_sibling_left_3(~K, ~V, ~cmp, p, pn, wn, _) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_sibling_left_2(~K, ~V, ~cmp, p, pn, Tuple{m2, wn})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
      delete_sibling_left_3_s(~K, ~V, ~cmp, p, pn, wn, MI.read(~K, ~V, ~cmp, m2, M.node_left(~K, wn)), read_g(~K, ~V, ~cmp, m2, M.node_left(~K, wn), g_pair_result))


def delete_sibling_right_2_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +pn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_sibling_right_2(~K, ~V, ~cmp, p, pn, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m2, +wn}:
      delete_sibling_right_3_g(~K, ~V, ~cmp, p, pn, wn, MI.read(~K, ~V, ~cmp, m2, M.node_right(~K, wn)), read_g(~K, ~V, ~cmp, m2, M.node_right(~K, wn), g_pair_result))

def delete_sibling_right_2_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +pn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.delete_sibling_right_2(~K, ~V, ~cmp, p, pn, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_sibling_right_2(~K, ~V, ~cmp, p, pn, pair_result)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
  match pair_result:
    case Tuple{+m2, +wn}:
      %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m2), M.node_right(~K, wn)), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m2, M.node_right(~K, wn))), read_s(~K, ~V, ~cmp, m2, M.node_right(~K, wn), g_pair_result)) : {M.delete_sibling_right_3(~K, ~V, ~cmp, p, pn, wn, _) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_sibling_right_2(~K, ~V, ~cmp, p, pn, Tuple{m2, wn})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
      delete_sibling_right_3_s(~K, ~V, ~cmp, p, pn, wn, MI.read(~K, ~V, ~cmp, m2, M.node_right(~K, wn)), read_g(~K, ~V, ~cmp, m2, M.node_right(~K, wn), g_pair_result))


def insert_fix_step_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +z: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.Fix, MI.insert_fix_step_1(~K, ~V, ~cmp, z, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m1, +zn}:
      insert_fix_step_2_g(~K, ~V, ~cmp, z, zn, MI.read(~K, ~V, ~cmp, m1, M.node_parent(~K, zn)), read_g(~K, ~V, ~cmp, m1, M.node_parent(~K, zn), g_pair_result))

def insert_fix_step_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +z: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.insert_fix_step_1(~K, ~V, ~cmp, z, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_fix_step_1(~K, ~V, ~cmp, z, pair_result)) : M.TreeMap<K, V, cmp> & M.Fix}:
  match pair_result:
    case Tuple{+m1, +zn}:
      %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m1), M.node_parent(~K, zn)), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m1, M.node_parent(~K, zn))), read_s(~K, ~V, ~cmp, m1, M.node_parent(~K, zn), g_pair_result)) : {M.insert_fix_step_2(~K, ~V, ~cmp, z, zn, _) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_fix_step_1(~K, ~V, ~cmp, z, Tuple{m1, zn})) : M.TreeMap<K, V, cmp> & M.Fix}
      insert_fix_step_2_s(~K, ~V, ~cmp, z, zn, MI.read(~K, ~V, ~cmp, m1, M.node_parent(~K, zn)), read_g(~K, ~V, ~cmp, m1, M.node_parent(~K, zn), g_pair_result))


def delete_sibling_left_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_sibling_left_1(~K, ~V, ~cmp, p, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m1, +pn}:
      delete_sibling_left_2_g(~K, ~V, ~cmp, p, pn, MI.read(~K, ~V, ~cmp, m1, M.node_right(~K, pn)), read_g(~K, ~V, ~cmp, m1, M.node_right(~K, pn), g_pair_result))

def delete_sibling_left_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.delete_sibling_left_1(~K, ~V, ~cmp, p, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_sibling_left_1(~K, ~V, ~cmp, p, pair_result)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
  match pair_result:
    case Tuple{+m1, +pn}:
      %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m1), M.node_right(~K, pn)), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m1, M.node_right(~K, pn))), read_s(~K, ~V, ~cmp, m1, M.node_right(~K, pn), g_pair_result)) : {M.delete_sibling_left_2(~K, ~V, ~cmp, p, pn, _) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_sibling_left_1(~K, ~V, ~cmp, p, Tuple{m1, pn})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
      delete_sibling_left_2_s(~K, ~V, ~cmp, p, pn, MI.read(~K, ~V, ~cmp, m1, M.node_right(~K, pn)), read_g(~K, ~V, ~cmp, m1, M.node_right(~K, pn), g_pair_result))


def delete_sibling_right_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_sibling_right_1(~K, ~V, ~cmp, p, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m1, +pn}:
      delete_sibling_right_2_g(~K, ~V, ~cmp, p, pn, MI.read(~K, ~V, ~cmp, m1, M.node_left(~K, pn)), read_g(~K, ~V, ~cmp, m1, M.node_left(~K, pn), g_pair_result))

def delete_sibling_right_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.delete_sibling_right_1(~K, ~V, ~cmp, p, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_sibling_right_1(~K, ~V, ~cmp, p, pair_result)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
  match pair_result:
    case Tuple{+m1, +pn}:
      %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m1), M.node_left(~K, pn)), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m1, M.node_left(~K, pn))), read_s(~K, ~V, ~cmp, m1, M.node_left(~K, pn), g_pair_result)) : {M.delete_sibling_right_2(~K, ~V, ~cmp, p, pn, _) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_sibling_right_1(~K, ~V, ~cmp, p, Tuple{m1, pn})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
      delete_sibling_right_2_s(~K, ~V, ~cmp, p, pn, MI.read(~K, ~V, ~cmp, m1, M.node_left(~K, pn)), read_g(~K, ~V, ~cmp, m1, M.node_left(~K, pn), g_pair_result))


def insert_fix_step_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +z: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.Fix, MI.insert_fix_step(~K, ~V, ~cmp, m, z)) == True{} : Bool}:
  insert_fix_step_1_g(~K, ~V, ~cmp, z, MI.read(~K, ~V, ~cmp, m, z), read_g(~K, ~V, ~cmp, m, z, g_m))

def insert_fix_step_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +z: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.insert_fix_step(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), z) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_fix_step(~K, ~V, ~cmp, m, z)) : M.TreeMap<K, V, cmp> & M.Fix}:
  %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), z), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m, z)), read_s(~K, ~V, ~cmp, m, z, g_m)) : {M.insert_fix_step_1(~K, ~V, ~cmp, z, _) == MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_fix_step(~K, ~V, ~cmp, m, z)) : M.TreeMap<K, V, cmp> & M.Fix}
  insert_fix_step_1_s(~K, ~V, ~cmp, z, MI.read(~K, ~V, ~cmp, m, z), read_g(~K, ~V, ~cmp, m, z, g_m))


def delete_sibling_left_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_sibling_left(~K, ~V, ~cmp, m, p)) == True{} : Bool}:
  delete_sibling_left_1_g(~K, ~V, ~cmp, p, MI.read(~K, ~V, ~cmp, m, p), read_g(~K, ~V, ~cmp, m, p, g_m))

def delete_sibling_left_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.delete_sibling_left(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_sibling_left(~K, ~V, ~cmp, m, p)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
  %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m, p)), read_s(~K, ~V, ~cmp, m, p, g_m)) : {M.delete_sibling_left_1(~K, ~V, ~cmp, p, _) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_sibling_left(~K, ~V, ~cmp, m, p)) : M.TreeMap<K, V, cmp> & M.DeleteFix}
  delete_sibling_left_1_s(~K, ~V, ~cmp, p, MI.read(~K, ~V, ~cmp, m, p), read_g(~K, ~V, ~cmp, m, p, g_m))


def delete_sibling_right_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_sibling_right(~K, ~V, ~cmp, m, p)) == True{} : Bool}:
  delete_sibling_right_1_g(~K, ~V, ~cmp, p, MI.read(~K, ~V, ~cmp, m, p), read_g(~K, ~V, ~cmp, m, p, g_m))

def delete_sibling_right_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.delete_sibling_right(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_sibling_right(~K, ~V, ~cmp, m, p)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
  %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m, p)), read_s(~K, ~V, ~cmp, m, p, g_m)) : {M.delete_sibling_right_1(~K, ~V, ~cmp, p, _) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_sibling_right(~K, ~V, ~cmp, m, p)) : M.TreeMap<K, V, cmp> & M.DeleteFix}
  delete_sibling_right_1_s(~K, ~V, ~cmp, p, MI.read(~K, ~V, ~cmp, m, p), read_g(~K, ~V, ~cmp, m, p, g_m))


def insert_fix_loop_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +fuel: Nat, st: ST.Sh<K, V> & M.Fix, +g_st: {MI.dgp(K, V, M.Fix, st) == True{} : Bool}) -> {MI.dg(K, V, MI.insert_fix_loop(~K, ~V, ~cmp, fuel, st)) == True{} : Bool}:
  match fuel st:
    case 0n Tuple{+px4, +px5}:
      black_root_g(~K, ~V, ~cmp, px4, g_st)
    case 1n+ +px3 Tuple{+px6, M.Fix{+px8, False{}}}:
      black_root_g(~K, ~V, ~cmp, px6, g_st)
    case 1n+ +px3 Tuple{+px6, M.Fix{+px8, True{}}}:
      insert_fix_loop_g(~K, ~V, ~cmp, px3, MI.insert_fix_step(~K, ~V, ~cmp, px6, px8), insert_fix_step_g(~K, ~V, ~cmp, px6, px8, g_st))

def insert_fix_loop_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +fuel: Nat, st: ST.Sh<K, V> & M.Fix, +g_st: {MI.dgp(K, V, M.Fix, st) == True{} : Bool}) -> {M.insert_fix_loop(~K, ~V, ~cmp, fuel, MI.rp(~K, ~V, ~cmp, M.Fix, st)) == ST.real(~K, ~V, ~cmp, MI.insert_fix_loop(~K, ~V, ~cmp, fuel, st)) : M.TreeMap<K, V, cmp>}:
  match fuel st:
    case 0n Tuple{+px4, +px5}:
      black_root_s(~K, ~V, ~cmp, px4, g_st)
    case 1n+ +px3 Tuple{+px6, M.Fix{+px8, False{}}}:
      black_root_s(~K, ~V, ~cmp, px6, g_st)
    case 1n+ +px3 Tuple{+px6, M.Fix{+px8, True{}}}:
      %Equal.sym(M.TreeMap<K, V, cmp> & M.Fix, M.insert_fix_step(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, px6), px8), MI.rp(~K, ~V, ~cmp, M.Fix, MI.insert_fix_step(~K, ~V, ~cmp, px6, px8)), insert_fix_step_s(~K, ~V, ~cmp, px6, px8, g_st)) : {M.insert_fix_loop(~K, ~V, ~cmp, px3, _) == ST.real(~K, ~V, ~cmp, MI.insert_fix_loop(~K, ~V, ~cmp, 1n+ px3, Tuple{px6, M.Fix{px8, True{}}})) : M.TreeMap<K, V, cmp>}
      insert_fix_loop_s(~K, ~V, ~cmp, px3, MI.insert_fix_step(~K, ~V, ~cmp, px6, px8), insert_fix_step_g(~K, ~V, ~cmp, px6, px8, g_st))


def delete_red_sibling_left_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +w: Nat, +red_sibling: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_red_sibling_left(~K, ~V, ~cmp, m, p, w, red_sibling)) == True{} : Bool}:
  match red_sibling:
    case True{}:
      delete_sibling_left_g(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{}), p), p, rotate_left_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{}), p, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{}, set_red_g(~K, ~V, ~cmp, m, w, False{}, g_m))))
    case False{}:
      delete_sibling_left_g(~K, ~V, ~cmp, m, p, g_m)

def delete_red_sibling_left_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +w: Nat, +red_sibling: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.delete_red_sibling_left(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p, w, red_sibling) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_red_sibling_left(~K, ~V, ~cmp, m, p, w, red_sibling)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
  match red_sibling:
    case True{}:
      %Equal.sym(M.TreeMap<K, V, cmp>, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), w, False{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{})), set_red_s(~K, ~V, ~cmp, m, w, False{}, g_m)) : {M.delete_sibling_left(~K, ~V, ~cmp, M.rotate_left(~K, ~V, ~cmp, M.set_red(~K, ~V, ~cmp, _, p, True{}), p), p) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_red_sibling_left(~K, ~V, ~cmp, m, p, w, True{})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
      %Equal.sym(M.TreeMap<K, V, cmp>, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{})), p, True{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{})), set_red_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{}, set_red_g(~K, ~V, ~cmp, m, w, False{}, g_m))) : {M.delete_sibling_left(~K, ~V, ~cmp, M.rotate_left(~K, ~V, ~cmp, _, p), p) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_red_sibling_left(~K, ~V, ~cmp, m, p, w, True{})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
      %Equal.sym(M.TreeMap<K, V, cmp>, M.rotate_left(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{})), p), ST.real(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{}), p)), rotate_left_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{}), p, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{}, set_red_g(~K, ~V, ~cmp, m, w, False{}, g_m)))) : {M.delete_sibling_left(~K, ~V, ~cmp, _, p) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_red_sibling_left(~K, ~V, ~cmp, m, p, w, True{})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
      delete_sibling_left_s(~K, ~V, ~cmp, MI.rotate_left(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{}), p), p, rotate_left_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{}), p, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{}, set_red_g(~K, ~V, ~cmp, m, w, False{}, g_m))))
    case False{}:
      delete_sibling_left_s(~K, ~V, ~cmp, m, p, g_m)


def delete_red_sibling_right_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +w: Nat, +red_sibling: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_red_sibling_right(~K, ~V, ~cmp, m, p, w, red_sibling)) == True{} : Bool}:
  match red_sibling:
    case True{}:
      delete_sibling_right_g(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{}), p), p, rotate_right_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{}), p, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{}, set_red_g(~K, ~V, ~cmp, m, w, False{}, g_m))))
    case False{}:
      delete_sibling_right_g(~K, ~V, ~cmp, m, p, g_m)

def delete_red_sibling_right_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +w: Nat, +red_sibling: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.delete_red_sibling_right(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p, w, red_sibling) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_red_sibling_right(~K, ~V, ~cmp, m, p, w, red_sibling)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
  match red_sibling:
    case True{}:
      %Equal.sym(M.TreeMap<K, V, cmp>, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), w, False{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{})), set_red_s(~K, ~V, ~cmp, m, w, False{}, g_m)) : {M.delete_sibling_right(~K, ~V, ~cmp, M.rotate_right(~K, ~V, ~cmp, M.set_red(~K, ~V, ~cmp, _, p, True{}), p), p) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_red_sibling_right(~K, ~V, ~cmp, m, p, w, True{})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
      %Equal.sym(M.TreeMap<K, V, cmp>, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{})), p, True{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{})), set_red_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{}, set_red_g(~K, ~V, ~cmp, m, w, False{}, g_m))) : {M.delete_sibling_right(~K, ~V, ~cmp, M.rotate_right(~K, ~V, ~cmp, _, p), p) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_red_sibling_right(~K, ~V, ~cmp, m, p, w, True{})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
      %Equal.sym(M.TreeMap<K, V, cmp>, M.rotate_right(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{})), p), ST.real(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{}), p)), rotate_right_s(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{}), p, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{}, set_red_g(~K, ~V, ~cmp, m, w, False{}, g_m)))) : {M.delete_sibling_right(~K, ~V, ~cmp, _, p) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_red_sibling_right(~K, ~V, ~cmp, m, p, w, True{})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
      delete_sibling_right_s(~K, ~V, ~cmp, MI.rotate_right(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{}), p), p, rotate_right_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{}), p, set_red_g(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, w, False{}), p, True{}, set_red_g(~K, ~V, ~cmp, m, w, False{}, g_m))))
    case False{}:
      delete_sibling_right_s(~K, ~V, ~cmp, m, p, g_m)


def insert_fixed_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, r: ST.Sh<K, V> & Nat, +g_r: {MI.dgp(K, V, Nat, r) == True{} : Bool}) -> {MI.dg(K, V, MI.insert_fixed(~K, ~V, ~cmp, id, r)) == True{} : Bool}:
  match r:
    case Tuple{+m, +n}:
      insert_fix_loop_g(~K, ~V, ~cmp, 1n+n, (m, M.Fix{id, True{}}), g_r)

def insert_fixed_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, r: ST.Sh<K, V> & Nat, +g_r: {MI.dgp(K, V, Nat, r) == True{} : Bool}) -> {M.insert_fixed(~K, ~V, ~cmp, id, MI.rp(~K, ~V, ~cmp, Nat, r)) == ST.real(~K, ~V, ~cmp, MI.insert_fixed(~K, ~V, ~cmp, id, r)) : M.TreeMap<K, V, cmp>}:
  match r:
    case Tuple{+m, +n}:
      insert_fix_loop_s(~K, ~V, ~cmp, 1n+n, (m, M.Fix{id, True{}}), g_r)


def delete_side_left_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +pn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_side_left_1(~K, ~V, ~cmp, p, pn, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m1, +wn}:
      delete_red_sibling_left_g(~K, ~V, ~cmp, m1, p, M.node_right(~K, pn), M.node_red(~K, wn), g_pair_result)

def delete_side_left_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +pn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.delete_side_left_1(~K, ~V, ~cmp, p, pn, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_side_left_1(~K, ~V, ~cmp, p, pn, pair_result)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
  match pair_result:
    case Tuple{+m1, +wn}:
      delete_red_sibling_left_s(~K, ~V, ~cmp, m1, p, M.node_right(~K, pn), M.node_red(~K, wn), g_pair_result)


def delete_side_right_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +pn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_side_right_1(~K, ~V, ~cmp, p, pn, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m1, +wn}:
      delete_red_sibling_right_g(~K, ~V, ~cmp, m1, p, M.node_left(~K, pn), M.node_red(~K, wn), g_pair_result)

def delete_side_right_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +pn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.delete_side_right_1(~K, ~V, ~cmp, p, pn, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_side_right_1(~K, ~V, ~cmp, p, pn, pair_result)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
  match pair_result:
    case Tuple{+m1, +wn}:
      delete_red_sibling_right_s(~K, ~V, ~cmp, m1, p, M.node_left(~K, pn), M.node_red(~K, wn), g_pair_result)


def put_allocated_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +on_left: Bool, r: ST.Sh<K, V> & Result<&2, &2, M.Rejected<K, V>, Nat>, +g_r: {MI.dgp(K, V, Result<&2, &2, M.Rejected<K, V>, Nat>, r) == True{} : Bool}) -> {MI.dgp(K, V, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put_allocated(~K, ~V, ~cmp, p, on_left, r)) == True{} : Bool}:
  match r:
    case Tuple{+px2, Done{+px4}}:
      insert_fixed_g(~K, ~V, ~cmp, px4, MI.size(~K, ~V, ~cmp, MI.insert_header(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, px2, p, px4, on_left), px4, p, on_left)), size_g(~K, ~V, ~cmp, MI.insert_header(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, px2, p, px4, on_left), px4, p, on_left), insert_header_g(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, px2, p, px4, on_left), px4, p, on_left, attach_g(~K, ~V, ~cmp, px2, p, px4, on_left, g_r))))
    case Tuple{+px2, Fail{+px5}}:
      g_r

def put_allocated_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +p: Nat, +on_left: Bool, r: ST.Sh<K, V> & Result<&2, &2, M.Rejected<K, V>, Nat>, +g_r: {MI.dgp(K, V, Result<&2, &2, M.Rejected<K, V>, Nat>, r) == True{} : Bool}) -> {M.put_allocated(~K, ~V, ~cmp, p, on_left, MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Nat>, r)) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put_allocated(~K, ~V, ~cmp, p, on_left, r)) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>}:
  match r:
    case Tuple{+px2, Done{+px4}}:
      %Equal.sym(M.TreeMap<K, V, cmp>, M.attach(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, px2), p, px4, on_left), ST.real(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, px2, p, px4, on_left)), attach_s(~K, ~V, ~cmp, px2, p, px4, on_left, g_r)) : {(M.insert_fixed(~K, ~V, ~cmp, px4, M.size(~K, ~V, ~cmp, M.insert_header(~K, ~V, ~cmp, _, px4, p, on_left))), Done{None{}}) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put_allocated(~K, ~V, ~cmp, p, on_left, Tuple{px2, Done{px4}})) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>}
      %Equal.sym(M.TreeMap<K, V, cmp>, M.insert_header(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, px2, p, px4, on_left)), px4, p, on_left), ST.real(~K, ~V, ~cmp, MI.insert_header(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, px2, p, px4, on_left), px4, p, on_left)), insert_header_s(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, px2, p, px4, on_left), px4, p, on_left, attach_g(~K, ~V, ~cmp, px2, p, px4, on_left, g_r))) : {(M.insert_fixed(~K, ~V, ~cmp, px4, M.size(~K, ~V, ~cmp, _)), Done{None{}}) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put_allocated(~K, ~V, ~cmp, p, on_left, Tuple{px2, Done{px4}})) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>}
      %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.size(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.insert_header(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, px2, p, px4, on_left), px4, p, on_left))), MI.rp(~K, ~V, ~cmp, Nat, MI.size(~K, ~V, ~cmp, MI.insert_header(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, px2, p, px4, on_left), px4, p, on_left))), size_s(~K, ~V, ~cmp, MI.insert_header(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, px2, p, px4, on_left), px4, p, on_left), insert_header_g(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, px2, p, px4, on_left), px4, p, on_left, attach_g(~K, ~V, ~cmp, px2, p, px4, on_left, g_r)))) : {(M.insert_fixed(~K, ~V, ~cmp, px4, _), Done{None{}}) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put_allocated(~K, ~V, ~cmp, p, on_left, Tuple{px2, Done{px4}})) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>}
      %Equal.sym(M.TreeMap<K, V, cmp>, M.insert_fixed(~K, ~V, ~cmp, px4, MI.rp(~K, ~V, ~cmp, Nat, MI.size(~K, ~V, ~cmp, MI.insert_header(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, px2, p, px4, on_left), px4, p, on_left)))), ST.real(~K, ~V, ~cmp, MI.insert_fixed(~K, ~V, ~cmp, px4, MI.size(~K, ~V, ~cmp, MI.insert_header(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, px2, p, px4, on_left), px4, p, on_left)))), insert_fixed_s(~K, ~V, ~cmp, px4, MI.size(~K, ~V, ~cmp, MI.insert_header(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, px2, p, px4, on_left), px4, p, on_left)), size_g(~K, ~V, ~cmp, MI.insert_header(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, px2, p, px4, on_left), px4, p, on_left), insert_header_g(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, px2, p, px4, on_left), px4, p, on_left, attach_g(~K, ~V, ~cmp, px2, p, px4, on_left, g_r))))) : {(_, Done{None{}}) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put_allocated(~K, ~V, ~cmp, p, on_left, Tuple{px2, Done{px4}})) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>}
      {==}
    case Tuple{+px2, Fail{+px5}}:
      {==}


def delete_side_left_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +pn: M.Node<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_side_left(~K, ~V, ~cmp, m, p, pn)) == True{} : Bool}:
  delete_side_left_1_g(~K, ~V, ~cmp, p, pn, MI.read(~K, ~V, ~cmp, m, M.node_right(~K, pn)), read_g(~K, ~V, ~cmp, m, M.node_right(~K, pn), g_m))

def delete_side_left_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +pn: M.Node<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.delete_side_left(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p, pn) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_side_left(~K, ~V, ~cmp, m, p, pn)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
  %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), M.node_right(~K, pn)), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m, M.node_right(~K, pn))), read_s(~K, ~V, ~cmp, m, M.node_right(~K, pn), g_m)) : {M.delete_side_left_1(~K, ~V, ~cmp, p, pn, _) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_side_left(~K, ~V, ~cmp, m, p, pn)) : M.TreeMap<K, V, cmp> & M.DeleteFix}
  delete_side_left_1_s(~K, ~V, ~cmp, p, pn, MI.read(~K, ~V, ~cmp, m, M.node_right(~K, pn)), read_g(~K, ~V, ~cmp, m, M.node_right(~K, pn), g_m))


def delete_side_right_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +pn: M.Node<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_side_right(~K, ~V, ~cmp, m, p, pn)) == True{} : Bool}:
  delete_side_right_1_g(~K, ~V, ~cmp, p, pn, MI.read(~K, ~V, ~cmp, m, M.node_left(~K, pn)), read_g(~K, ~V, ~cmp, m, M.node_left(~K, pn), g_m))

def delete_side_right_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +p: Nat, +pn: M.Node<K>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.delete_side_right(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), p, pn) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_side_right(~K, ~V, ~cmp, m, p, pn)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
  %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), M.node_left(~K, pn)), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m, M.node_left(~K, pn))), read_s(~K, ~V, ~cmp, m, M.node_left(~K, pn), g_m)) : {M.delete_side_right_1(~K, ~V, ~cmp, p, pn, _) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_side_right(~K, ~V, ~cmp, m, p, pn)) : M.TreeMap<K, V, cmp> & M.DeleteFix}
  delete_side_right_1_s(~K, ~V, ~cmp, p, pn, MI.read(~K, ~V, ~cmp, m, M.node_left(~K, pn)), read_g(~K, ~V, ~cmp, m, M.node_left(~K, pn), g_m))


def put_found_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +k: K, +v: V, r: ST.Sh<K, V> & M.Search, +g_r: {MI.dgp(K, V, M.Search, r) == True{} : Bool}) -> {MI.dgp(K, V, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put_found(~K, ~V, ~cmp, k, v, r)) == True{} : Bool}:
  match r:
    case Tuple{+px2, M.Search{0n, +px5, +px6}}:
      put_allocated_g(~K, ~V, ~cmp, px5, px6, MI.allocate(~K, ~V, ~cmp, px2, px5, k, v), allocate_g(~K, ~V, ~cmp, px2, px5, k, v, g_r))
    case Tuple{+px2, M.Search{1n+ +px7, +px5, +px6}}:
      put_replaced_g(~K, ~V, ~cmp, MI.exchange(~K, ~V, ~cmp, px2, 1n+px7, Some{v}), exchange_g(~K, ~V, ~cmp, px2, 1n+px7, Some{v}, g_r))

def put_found_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +k: K, +v: V, r: ST.Sh<K, V> & M.Search, +g_r: {MI.dgp(K, V, M.Search, r) == True{} : Bool}) -> {M.put_found(~K, ~V, ~cmp, k, v, MI.rp(~K, ~V, ~cmp, M.Search, r)) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put_found(~K, ~V, ~cmp, k, v, r)) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>}:
  match r:
    case Tuple{+px2, M.Search{0n, +px5, +px6}}:
      %Equal.sym(M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Nat>, M.allocate(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, px2), px5, k, v), MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Nat>, MI.allocate(~K, ~V, ~cmp, px2, px5, k, v)), allocate_s(~K, ~V, ~cmp, px2, px5, k, v, g_r)) : {M.put_allocated(~K, ~V, ~cmp, px5, px6, _) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put_found(~K, ~V, ~cmp, k, v, Tuple{px2, M.Search{0n, px5, px6}})) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>}
      put_allocated_s(~K, ~V, ~cmp, px5, px6, MI.allocate(~K, ~V, ~cmp, px2, px5, k, v), allocate_g(~K, ~V, ~cmp, px2, px5, k, v, g_r))
    case Tuple{+px2, M.Search{1n+ +px7, +px5, +px6}}:
      %Equal.sym(M.TreeMap<K, V, cmp> & Maybe<&2, V>, M.exchange(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, px2), 1n+px7, Some{v}), MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.exchange(~K, ~V, ~cmp, px2, 1n+px7, Some{v})), exchange_s(~K, ~V, ~cmp, px2, 1n+px7, Some{v}, g_r)) : {M.put_replaced(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put_found(~K, ~V, ~cmp, k, v, Tuple{px2, M.Search{1n+ px7, px5, px6}})) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>}
      put_replaced_s(~K, ~V, ~cmp, MI.exchange(~K, ~V, ~cmp, px2, 1n+px7, Some{v}), exchange_g(~K, ~V, ~cmp, px2, 1n+px7, Some{v}, g_r))


def delete_side_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +x: Nat, +p: Nat, +pn: M.Node<K>, +on_left: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_side(~K, ~V, ~cmp, m, x, p, pn, on_left)) == True{} : Bool}:
  match on_left:
    case True{}:
      delete_side_left_g(~K, ~V, ~cmp, m, p, pn, g_m)
    case False{}:
      delete_side_right_g(~K, ~V, ~cmp, m, p, pn, g_m)

def delete_side_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +x: Nat, +p: Nat, +pn: M.Node<K>, +on_left: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.delete_side(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), x, p, pn, on_left) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_side(~K, ~V, ~cmp, m, x, p, pn, on_left)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
  match on_left:
    case True{}:
      delete_side_left_s(~K, ~V, ~cmp, m, p, pn, g_m)
    case False{}:
      delete_side_right_s(~K, ~V, ~cmp, m, p, pn, g_m)


def put_absent_found_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +k: K, +v: V, r: ST.Sh<K, V> & M.Search, +g_r: {MI.dgp(K, V, M.Search, r) == True{} : Bool}) -> {MI.dgp(K, V, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put_absent_found(~K, ~V, ~cmp, k, v, r)) == True{} : Bool}:
  match r:
    case Tuple{+px2, M.Search{0n, +px5, +px6}}:
      put_allocated_g(~K, ~V, ~cmp, px5, px6, MI.allocate(~K, ~V, ~cmp, px2, px5, k, v), allocate_g(~K, ~V, ~cmp, px2, px5, k, v, g_r))
    case Tuple{+px2, M.Search{1n+ +px7, +px5, +px6}}:
      put_replaced_g(~K, ~V, ~cmp, MI.get_id(~K, ~V, ~cmp, px2, 1n+px7), get_id_g(~K, ~V, ~cmp, px2, 1n+px7, g_r))

def put_absent_found_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +k: K, +v: V, r: ST.Sh<K, V> & M.Search, +g_r: {MI.dgp(K, V, M.Search, r) == True{} : Bool}) -> {M.put_absent_found(~K, ~V, ~cmp, k, v, MI.rp(~K, ~V, ~cmp, M.Search, r)) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put_absent_found(~K, ~V, ~cmp, k, v, r)) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>}:
  match r:
    case Tuple{+px2, M.Search{0n, +px5, +px6}}:
      %Equal.sym(M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Nat>, M.allocate(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, px2), px5, k, v), MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Nat>, MI.allocate(~K, ~V, ~cmp, px2, px5, k, v)), allocate_s(~K, ~V, ~cmp, px2, px5, k, v, g_r)) : {M.put_allocated(~K, ~V, ~cmp, px5, px6, _) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put_absent_found(~K, ~V, ~cmp, k, v, Tuple{px2, M.Search{0n, px5, px6}})) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>}
      put_allocated_s(~K, ~V, ~cmp, px5, px6, MI.allocate(~K, ~V, ~cmp, px2, px5, k, v), allocate_g(~K, ~V, ~cmp, px2, px5, k, v, g_r))
    case Tuple{+px2, M.Search{1n+ +px7, +px5, +px6}}:
      %Equal.sym(M.TreeMap<K, V, cmp> & Maybe<&2, V>, M.get_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, px2), 1n+px7), MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.get_id(~K, ~V, ~cmp, px2, 1n+px7)), get_id_s(~K, ~V, ~cmp, px2, 1n+px7, g_r)) : {M.put_replaced(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put_absent_found(~K, ~V, ~cmp, k, v, Tuple{px2, M.Search{1n+ px7, px5, px6}})) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>}
      put_replaced_s(~K, ~V, ~cmp, MI.get_id(~K, ~V, ~cmp, px2, 1n+px7), get_id_g(~K, ~V, ~cmp, px2, 1n+px7, g_r))


def put_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +v: V, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put(~K, ~V, ~cmp, m, k, v)) == True{} : Bool}:
  put_found_g(~K, ~V, ~cmp, k, v, MI.search(~K, ~V, ~cmp, m, k), search_g(~K, ~V, ~cmp, m, k, g_m))

def put_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +v: V, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.put(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k, v) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put(~K, ~V, ~cmp, m, k, v)) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>}:
  %Equal.sym(M.TreeMap<K, V, cmp> & M.Search, M.search(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k), MI.rp(~K, ~V, ~cmp, M.Search, MI.search(~K, ~V, ~cmp, m, k)), search_s(~K, ~V, ~cmp, m, k, g_m)) : {M.put_found(~K, ~V, ~cmp, k, v, _) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put(~K, ~V, ~cmp, m, k, v)) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>}
  put_found_s(~K, ~V, ~cmp, k, v, MI.search(~K, ~V, ~cmp, m, k), search_g(~K, ~V, ~cmp, m, k, g_m))


def delete_stop_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +x: Nat, +p: Nat, +pn: M.Node<K>, +stop: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_stop(~K, ~V, ~cmp, m, x, p, pn, stop)) == True{} : Bool}:
  match stop:
    case True{}:
      set_red_g(~K, ~V, ~cmp, m, x, False{}, g_m)
    case False{}:
      delete_side_g(~K, ~V, ~cmp, m, x, p, pn, Nat.is_eq(x, M.node_left(~K, pn)), g_m)

def delete_stop_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +x: Nat, +p: Nat, +pn: M.Node<K>, +stop: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.delete_stop(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), x, p, pn, stop) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_stop(~K, ~V, ~cmp, m, x, p, pn, stop)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
  match stop:
    case True{}:
      %Equal.sym(M.TreeMap<K, V, cmp>, M.set_red(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), x, False{}), ST.real(~K, ~V, ~cmp, MI.set_red(~K, ~V, ~cmp, m, x, False{})), set_red_s(~K, ~V, ~cmp, m, x, False{}, g_m)) : {(_, M.DF{0n, 0n, False{}}) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_stop(~K, ~V, ~cmp, m, x, p, pn, True{})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
      {==}
    case False{}:
      delete_side_s(~K, ~V, ~cmp, m, x, p, pn, Nat.is_eq(x, M.node_left(~K, pn)), g_m)


def put_if_absent_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +v: V, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put_if_absent(~K, ~V, ~cmp, m, k, v)) == True{} : Bool}:
  put_absent_found_g(~K, ~V, ~cmp, k, v, MI.search(~K, ~V, ~cmp, m, k), search_g(~K, ~V, ~cmp, m, k, g_m))

def put_if_absent_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +v: V, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.put_if_absent(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k, v) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put_if_absent(~K, ~V, ~cmp, m, k, v)) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>}:
  %Equal.sym(M.TreeMap<K, V, cmp> & M.Search, M.search(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k), MI.rp(~K, ~V, ~cmp, M.Search, MI.search(~K, ~V, ~cmp, m, k)), search_s(~K, ~V, ~cmp, m, k, g_m)) : {M.put_absent_found(~K, ~V, ~cmp, k, v, _) == MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put_if_absent(~K, ~V, ~cmp, m, k, v)) : M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>}
  put_absent_found_s(~K, ~V, ~cmp, k, v, MI.search(~K, ~V, ~cmp, m, k), search_g(~K, ~V, ~cmp, m, k, g_m))


def delete_fix_step_3_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, +p: Nat, +root_node: Nat, +xn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_fix_step_3(~K, ~V, ~cmp, x, p, root_node, xn, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m3, +pn}:
      delete_stop_g(~K, ~V, ~cmp, m3, x, p, pn, Bool.or(Nat.is_eq(x, root_node), M.node_red(~K, xn)), g_pair_result)

def delete_fix_step_3_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, +p: Nat, +root_node: Nat, +xn: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.delete_fix_step_3(~K, ~V, ~cmp, x, p, root_node, xn, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_fix_step_3(~K, ~V, ~cmp, x, p, root_node, xn, pair_result)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
  match pair_result:
    case Tuple{+m3, +pn}:
      delete_stop_s(~K, ~V, ~cmp, m3, x, p, pn, Bool.or(Nat.is_eq(x, root_node), M.node_red(~K, xn)), g_pair_result)


def view_put_checked_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +v: V, +lower: M.Bound<K>, +upper: M.Bound<K>, +descending: Bool, +valid: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgvp(K, V, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.view_put_checked(~K, ~V, ~cmp, m, k, v, lower, upper, descending, valid)) == True{} : Bool}:
  match valid:
    case True{}:
      view_put_finish_g(~K, ~V, ~cmp, lower, upper, descending, MI.put(~K, ~V, ~cmp, m, k, v), put_g(~K, ~V, ~cmp, m, k, v, g_m))
    case False{}:
      g_m

def view_put_checked_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +v: V, +lower: M.Bound<K>, +upper: M.Bound<K>, +descending: Bool, +valid: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.view_put_checked(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k, v, lower, upper, descending, valid) == MI.rvp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.view_put_checked(~K, ~V, ~cmp, m, k, v, lower, upper, descending, valid)) : M.View<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>}:
  match valid:
    case True{}:
      %Equal.sym(M.TreeMap<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, M.put(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k, v), MI.rp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.put(~K, ~V, ~cmp, m, k, v)), put_s(~K, ~V, ~cmp, m, k, v, g_m)) : {M.view_put_finish(~K, ~V, ~cmp, lower, upper, descending, _) == MI.rvp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.view_put_checked(~K, ~V, ~cmp, m, k, v, lower, upper, descending, True{})) : M.View<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>}
      view_put_finish_s(~K, ~V, ~cmp, lower, upper, descending, MI.put(~K, ~V, ~cmp, m, k, v), put_g(~K, ~V, ~cmp, m, k, v, g_m))
    case False{}:
      {==}


def delete_fix_step_2_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, +p: Nat, +root_node: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_fix_step_2(~K, ~V, ~cmp, x, p, root_node, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m2, +xn}:
      delete_fix_step_3_g(~K, ~V, ~cmp, x, p, root_node, xn, MI.read(~K, ~V, ~cmp, m2, p), read_g(~K, ~V, ~cmp, m2, p, g_pair_result))

def delete_fix_step_2_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, +p: Nat, +root_node: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.delete_fix_step_2(~K, ~V, ~cmp, x, p, root_node, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_fix_step_2(~K, ~V, ~cmp, x, p, root_node, pair_result)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
  match pair_result:
    case Tuple{+m2, +xn}:
      %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m2), p), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m2, p)), read_s(~K, ~V, ~cmp, m2, p, g_pair_result)) : {M.delete_fix_step_3(~K, ~V, ~cmp, x, p, root_node, xn, _) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_fix_step_2(~K, ~V, ~cmp, x, p, root_node, Tuple{m2, xn})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
      delete_fix_step_3_s(~K, ~V, ~cmp, x, p, root_node, xn, MI.read(~K, ~V, ~cmp, m2, p), read_g(~K, ~V, ~cmp, m2, p, g_pair_result))


def view_put_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +k: K, +v: V, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {MI.dgvp(K, V, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.view_put(~K, ~V, ~cmp, view, k, v)) == True{} : Bool}:
  match view:
    case MI.MV{+m, +lower, +upper, +descending}:
      view_put_checked_g(~K, ~V, ~cmp, m, k, v, lower, upper, descending, M.in_range(~K, ~V, ~cmp, k, lower, upper), g_view)

def view_put_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +k: K, +v: V, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {M.view_put(~K, ~V, ~cmp, MI.rv(~K, ~V, ~cmp, view), k, v) == MI.rvp(~K, ~V, ~cmp, Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>, MI.view_put(~K, ~V, ~cmp, view, k, v)) : M.View<K, V, cmp> & Result<&2, &2, M.Rejected<K, V>, Maybe<&2, V>>}:
  match view:
    case MI.MV{+m, +lower, +upper, +descending}:
      view_put_checked_s(~K, ~V, ~cmp, m, k, v, lower, upper, descending, M.in_range(~K, ~V, ~cmp, k, lower, upper), g_view)


def delete_fix_step_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, +p: Nat, pair_result: ST.Sh<K, V> & Nat, +g_pair_result: {MI.dgp(K, V, Nat, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_fix_step_1(~K, ~V, ~cmp, x, p, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m1, +root_node}:
      delete_fix_step_2_g(~K, ~V, ~cmp, x, p, root_node, MI.read(~K, ~V, ~cmp, m1, x), read_g(~K, ~V, ~cmp, m1, x, g_pair_result))

def delete_fix_step_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +x: Nat, +p: Nat, pair_result: ST.Sh<K, V> & Nat, +g_pair_result: {MI.dgp(K, V, Nat, pair_result) == True{} : Bool}) -> {M.delete_fix_step_1(~K, ~V, ~cmp, x, p, MI.rp(~K, ~V, ~cmp, Nat, pair_result)) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_fix_step_1(~K, ~V, ~cmp, x, p, pair_result)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
  match pair_result:
    case Tuple{+m1, +root_node}:
      %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m1), x), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m1, x)), read_s(~K, ~V, ~cmp, m1, x, g_pair_result)) : {M.delete_fix_step_2(~K, ~V, ~cmp, x, p, root_node, _) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_fix_step_1(~K, ~V, ~cmp, x, p, Tuple{m1, root_node})) : M.TreeMap<K, V, cmp> & M.DeleteFix}
      delete_fix_step_2_s(~K, ~V, ~cmp, x, p, root_node, MI.read(~K, ~V, ~cmp, m1, x), read_g(~K, ~V, ~cmp, m1, x, g_pair_result))


def delete_fix_step_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +x: Nat, +p: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, M.DeleteFix, MI.delete_fix_step(~K, ~V, ~cmp, m, x, p)) == True{} : Bool}:
  delete_fix_step_1_g(~K, ~V, ~cmp, x, p, MI.root_id(~K, ~V, ~cmp, m), root_id_g(~K, ~V, ~cmp, m, g_m))

def delete_fix_step_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +x: Nat, +p: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.delete_fix_step(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), x, p) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_fix_step(~K, ~V, ~cmp, m, x, p)) : M.TreeMap<K, V, cmp> & M.DeleteFix}:
  %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.root_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)), MI.rp(~K, ~V, ~cmp, Nat, MI.root_id(~K, ~V, ~cmp, m)), root_id_s(~K, ~V, ~cmp, m, g_m)) : {M.delete_fix_step_1(~K, ~V, ~cmp, x, p, _) == MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_fix_step(~K, ~V, ~cmp, m, x, p)) : M.TreeMap<K, V, cmp> & M.DeleteFix}
  delete_fix_step_1_s(~K, ~V, ~cmp, x, p, MI.root_id(~K, ~V, ~cmp, m), root_id_g(~K, ~V, ~cmp, m, g_m))


def delete_fix_loop_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +fuel: Nat, st: ST.Sh<K, V> & M.DeleteFix, +g_st: {MI.dgp(K, V, M.DeleteFix, st) == True{} : Bool}) -> {MI.dg(K, V, MI.delete_fix_loop(~K, ~V, ~cmp, fuel, st)) == True{} : Bool}:
  match fuel st:
    case 0n Tuple{+px4, +px5}:
      black_root_g(~K, ~V, ~cmp, px4, g_st)
    case 1n+ +px3 Tuple{+px6, M.DF{+px8, +px9, False{}}}:
      black_root_g(~K, ~V, ~cmp, px6, g_st)
    case 1n+ +px3 Tuple{+px6, M.DF{+px8, +px9, True{}}}:
      delete_fix_loop_g(~K, ~V, ~cmp, px3, MI.delete_fix_step(~K, ~V, ~cmp, px6, px8, px9), delete_fix_step_g(~K, ~V, ~cmp, px6, px8, px9, g_st))

def delete_fix_loop_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +fuel: Nat, st: ST.Sh<K, V> & M.DeleteFix, +g_st: {MI.dgp(K, V, M.DeleteFix, st) == True{} : Bool}) -> {M.delete_fix_loop(~K, ~V, ~cmp, fuel, MI.rp(~K, ~V, ~cmp, M.DeleteFix, st)) == ST.real(~K, ~V, ~cmp, MI.delete_fix_loop(~K, ~V, ~cmp, fuel, st)) : M.TreeMap<K, V, cmp>}:
  match fuel st:
    case 0n Tuple{+px4, +px5}:
      black_root_s(~K, ~V, ~cmp, px4, g_st)
    case 1n+ +px3 Tuple{+px6, M.DF{+px8, +px9, False{}}}:
      black_root_s(~K, ~V, ~cmp, px6, g_st)
    case 1n+ +px3 Tuple{+px6, M.DF{+px8, +px9, True{}}}:
      %Equal.sym(M.TreeMap<K, V, cmp> & M.DeleteFix, M.delete_fix_step(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, px6), px8, px9), MI.rp(~K, ~V, ~cmp, M.DeleteFix, MI.delete_fix_step(~K, ~V, ~cmp, px6, px8, px9)), delete_fix_step_s(~K, ~V, ~cmp, px6, px8, px9, g_st)) : {M.delete_fix_loop(~K, ~V, ~cmp, px3, _) == ST.real(~K, ~V, ~cmp, MI.delete_fix_loop(~K, ~V, ~cmp, 1n+ px3, Tuple{px6, M.DF{px8, px9, True{}}})) : M.TreeMap<K, V, cmp>}
      delete_fix_loop_s(~K, ~V, ~cmp, px3, MI.delete_fix_step(~K, ~V, ~cmp, px6, px8, px9), delete_fix_step_g(~K, ~V, ~cmp, px6, px8, px9, g_st))


def delete_repair_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +x: Nat, +p: Nat, +was_red: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.delete_repair(~K, ~V, ~cmp, m, x, p, was_red)) == True{} : Bool}:
  match m:
    case ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}:
      delete_fix_loop_g(~K, ~V, ~cmp, 1n+n, (ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, M.DF{x, p, Bool.not(was_red)}), g_m)

def delete_repair_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +x: Nat, +p: Nat, +was_red: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.delete_repair(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), x, p, was_red) == ST.real(~K, ~V, ~cmp, MI.delete_repair(~K, ~V, ~cmp, m, x, p, was_red)) : M.TreeMap<K, V, cmp>}:
  match m:
    case ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}:
      delete_fix_loop_s(~K, ~V, ~cmp, 1n+n, (ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, M.DF{x, p, Bool.not(was_red)}), g_m)


def unlink_2_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +node: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dg(K, V, MI.unlink_2(~K, ~V, ~cmp, id, node, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m2, +pn}:
      delete_repair_g(~K, ~V, ~cmp, MI.recycle(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, m2, M.node_parent(~K, node), M.pick(Nat, Nat.is_lt(0n, M.node_left(~K, node)), M.node_left(~K, node), M.node_right(~K, node)), Nat.is_eq(id, M.node_left(~K, pn))), id), M.pick(Nat, Nat.is_lt(0n, M.node_left(~K, node)), M.node_left(~K, node), M.node_right(~K, node)), M.node_parent(~K, node), M.node_red(~K, node), recycle_g(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, m2, M.node_parent(~K, node), M.pick(Nat, Nat.is_lt(0n, M.node_left(~K, node)), M.node_left(~K, node), M.node_right(~K, node)), Nat.is_eq(id, M.node_left(~K, pn))), id, attach_g(~K, ~V, ~cmp, m2, M.node_parent(~K, node), M.pick(Nat, Nat.is_lt(0n, M.node_left(~K, node)), M.node_left(~K, node), M.node_right(~K, node)), Nat.is_eq(id, M.node_left(~K, pn)), g_pair_result)))

def unlink_2_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, +node: M.Node<K>, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.unlink_2(~K, ~V, ~cmp, id, node, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == ST.real(~K, ~V, ~cmp, MI.unlink_2(~K, ~V, ~cmp, id, node, pair_result)) : M.TreeMap<K, V, cmp>}:
  match pair_result:
    case Tuple{+m2, +pn}:
      %Equal.sym(M.TreeMap<K, V, cmp>, M.attach(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m2), M.node_parent(~K, node), M.pick(Nat, Nat.is_lt(0n, M.node_left(~K, node)), M.node_left(~K, node), M.node_right(~K, node)), Nat.is_eq(id, M.node_left(~K, pn))), ST.real(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, m2, M.node_parent(~K, node), M.pick(Nat, Nat.is_lt(0n, M.node_left(~K, node)), M.node_left(~K, node), M.node_right(~K, node)), Nat.is_eq(id, M.node_left(~K, pn)))), attach_s(~K, ~V, ~cmp, m2, M.node_parent(~K, node), M.pick(Nat, Nat.is_lt(0n, M.node_left(~K, node)), M.node_left(~K, node), M.node_right(~K, node)), Nat.is_eq(id, M.node_left(~K, pn)), g_pair_result)) : {M.delete_repair(~K, ~V, ~cmp, M.recycle(~K, ~V, ~cmp, _, id), M.pick(Nat, Nat.is_lt(0n, M.node_left(~K, node)), M.node_left(~K, node), M.node_right(~K, node)), M.node_parent(~K, node), M.node_red(~K, node)) == ST.real(~K, ~V, ~cmp, MI.unlink_2(~K, ~V, ~cmp, id, node, Tuple{m2, pn})) : M.TreeMap<K, V, cmp>}
      %Equal.sym(M.TreeMap<K, V, cmp>, M.recycle(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, m2, M.node_parent(~K, node), M.pick(Nat, Nat.is_lt(0n, M.node_left(~K, node)), M.node_left(~K, node), M.node_right(~K, node)), Nat.is_eq(id, M.node_left(~K, pn)))), id), ST.real(~K, ~V, ~cmp, MI.recycle(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, m2, M.node_parent(~K, node), M.pick(Nat, Nat.is_lt(0n, M.node_left(~K, node)), M.node_left(~K, node), M.node_right(~K, node)), Nat.is_eq(id, M.node_left(~K, pn))), id)), recycle_s(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, m2, M.node_parent(~K, node), M.pick(Nat, Nat.is_lt(0n, M.node_left(~K, node)), M.node_left(~K, node), M.node_right(~K, node)), Nat.is_eq(id, M.node_left(~K, pn))), id, attach_g(~K, ~V, ~cmp, m2, M.node_parent(~K, node), M.pick(Nat, Nat.is_lt(0n, M.node_left(~K, node)), M.node_left(~K, node), M.node_right(~K, node)), Nat.is_eq(id, M.node_left(~K, pn)), g_pair_result))) : {M.delete_repair(~K, ~V, ~cmp, _, M.pick(Nat, Nat.is_lt(0n, M.node_left(~K, node)), M.node_left(~K, node), M.node_right(~K, node)), M.node_parent(~K, node), M.node_red(~K, node)) == ST.real(~K, ~V, ~cmp, MI.unlink_2(~K, ~V, ~cmp, id, node, Tuple{m2, pn})) : M.TreeMap<K, V, cmp>}
      delete_repair_s(~K, ~V, ~cmp, MI.recycle(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, m2, M.node_parent(~K, node), M.pick(Nat, Nat.is_lt(0n, M.node_left(~K, node)), M.node_left(~K, node), M.node_right(~K, node)), Nat.is_eq(id, M.node_left(~K, pn))), id), M.pick(Nat, Nat.is_lt(0n, M.node_left(~K, node)), M.node_left(~K, node), M.node_right(~K, node)), M.node_parent(~K, node), M.node_red(~K, node), recycle_g(~K, ~V, ~cmp, MI.attach(~K, ~V, ~cmp, m2, M.node_parent(~K, node), M.pick(Nat, Nat.is_lt(0n, M.node_left(~K, node)), M.node_left(~K, node), M.node_right(~K, node)), Nat.is_eq(id, M.node_left(~K, pn))), id, attach_g(~K, ~V, ~cmp, m2, M.node_parent(~K, node), M.pick(Nat, Nat.is_lt(0n, M.node_left(~K, node)), M.node_left(~K, node), M.node_right(~K, node)), Nat.is_eq(id, M.node_left(~K, pn)), g_pair_result)))


def unlink_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dg(K, V, MI.unlink_1(~K, ~V, ~cmp, id, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m1, +node}:
      unlink_2_g(~K, ~V, ~cmp, id, node, MI.read(~K, ~V, ~cmp, m1, M.node_parent(~K, node)), read_g(~K, ~V, ~cmp, m1, M.node_parent(~K, node), g_pair_result))

def unlink_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.unlink_1(~K, ~V, ~cmp, id, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == ST.real(~K, ~V, ~cmp, MI.unlink_1(~K, ~V, ~cmp, id, pair_result)) : M.TreeMap<K, V, cmp>}:
  match pair_result:
    case Tuple{+m1, +node}:
      %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m1), M.node_parent(~K, node)), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m1, M.node_parent(~K, node))), read_s(~K, ~V, ~cmp, m1, M.node_parent(~K, node), g_pair_result)) : {M.unlink_2(~K, ~V, ~cmp, id, node, _) == ST.real(~K, ~V, ~cmp, MI.unlink_1(~K, ~V, ~cmp, id, Tuple{m1, node})) : M.TreeMap<K, V, cmp>}
      unlink_2_s(~K, ~V, ~cmp, id, node, MI.read(~K, ~V, ~cmp, m1, M.node_parent(~K, node)), read_g(~K, ~V, ~cmp, m1, M.node_parent(~K, node), g_pair_result))


def unlink_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dg(K, V, MI.unlink(~K, ~V, ~cmp, m, id)) == True{} : Bool}:
  unlink_1_g(~K, ~V, ~cmp, id, MI.read(~K, ~V, ~cmp, m, id), read_g(~K, ~V, ~cmp, m, id, g_m))

def unlink_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.unlink(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id) == ST.real(~K, ~V, ~cmp, MI.unlink(~K, ~V, ~cmp, m, id)) : M.TreeMap<K, V, cmp>}:
  %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m, id)), read_s(~K, ~V, ~cmp, m, id, g_m)) : {M.unlink_1(~K, ~V, ~cmp, id, _) == ST.real(~K, ~V, ~cmp, MI.unlink(~K, ~V, ~cmp, m, id)) : M.TreeMap<K, V, cmp>}
  unlink_1_s(~K, ~V, ~cmp, id, MI.read(~K, ~V, ~cmp, m, id), read_g(~K, ~V, ~cmp, m, id, g_m))


def unlink_target_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh<K, V> & Nat, +g_r: {MI.dgp(K, V, Nat, r) == True{} : Bool}) -> {MI.dg(K, V, MI.unlink_target(~K, ~V, ~cmp, r)) == True{} : Bool}:
  match r:
    case Tuple{+m, +id}:
      refresh_ends_g(~K, ~V, ~cmp, MI.unlink(~K, ~V, ~cmp, m, id), unlink_g(~K, ~V, ~cmp, m, id, g_r))

def unlink_target_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh<K, V> & Nat, +g_r: {MI.dgp(K, V, Nat, r) == True{} : Bool}) -> {M.unlink_target(~K, ~V, ~cmp, MI.rp(~K, ~V, ~cmp, Nat, r)) == ST.real(~K, ~V, ~cmp, MI.unlink_target(~K, ~V, ~cmp, r)) : M.TreeMap<K, V, cmp>}:
  match r:
    case Tuple{+m, +id}:
      %Equal.sym(M.TreeMap<K, V, cmp>, M.unlink(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id), ST.real(~K, ~V, ~cmp, MI.unlink(~K, ~V, ~cmp, m, id)), unlink_s(~K, ~V, ~cmp, m, id, g_r)) : {M.refresh_ends(~K, ~V, ~cmp, _) == ST.real(~K, ~V, ~cmp, MI.unlink_target(~K, ~V, ~cmp, Tuple{m, id})) : M.TreeMap<K, V, cmp>}
      refresh_ends_s(~K, ~V, ~cmp, MI.unlink(~K, ~V, ~cmp, m, id), unlink_g(~K, ~V, ~cmp, m, id, g_r))


def remove_present_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, pair_result: ST.Sh<K, V> & Maybe<&2, V>, +g_pair_result: {MI.dgp(K, V, Maybe<&2, V>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, V>, MI.remove_present_1(~K, ~V, ~cmp, id, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m1, +value}:
      unlink_target_g(~K, ~V, ~cmp, MI.delete_target(~K, ~V, ~cmp, id, MI.read(~K, ~V, ~cmp, m1, id)), delete_target_g(~K, ~V, ~cmp, id, MI.read(~K, ~V, ~cmp, m1, id), read_g(~K, ~V, ~cmp, m1, id, g_pair_result)))

def remove_present_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, pair_result: ST.Sh<K, V> & Maybe<&2, V>, +g_pair_result: {MI.dgp(K, V, Maybe<&2, V>, pair_result) == True{} : Bool}) -> {M.remove_present_1(~K, ~V, ~cmp, id, MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, pair_result)) == MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.remove_present_1(~K, ~V, ~cmp, id, pair_result)) : M.TreeMap<K, V, cmp> & Maybe<&2, V>}:
  match pair_result:
    case Tuple{+m1, +value}:
      %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m1), id), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m1, id)), read_s(~K, ~V, ~cmp, m1, id, g_pair_result)) : {(M.unlink_target(~K, ~V, ~cmp, M.delete_target(~K, ~V, ~cmp, id, _)), value) == MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.remove_present_1(~K, ~V, ~cmp, id, Tuple{m1, value})) : M.TreeMap<K, V, cmp> & Maybe<&2, V>}
      %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.delete_target(~K, ~V, ~cmp, id, MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m1, id))), MI.rp(~K, ~V, ~cmp, Nat, MI.delete_target(~K, ~V, ~cmp, id, MI.read(~K, ~V, ~cmp, m1, id))), delete_target_s(~K, ~V, ~cmp, id, MI.read(~K, ~V, ~cmp, m1, id), read_g(~K, ~V, ~cmp, m1, id, g_pair_result))) : {(M.unlink_target(~K, ~V, ~cmp, _), value) == MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.remove_present_1(~K, ~V, ~cmp, id, Tuple{m1, value})) : M.TreeMap<K, V, cmp> & Maybe<&2, V>}
      %Equal.sym(M.TreeMap<K, V, cmp>, M.unlink_target(~K, ~V, ~cmp, MI.rp(~K, ~V, ~cmp, Nat, MI.delete_target(~K, ~V, ~cmp, id, MI.read(~K, ~V, ~cmp, m1, id)))), ST.real(~K, ~V, ~cmp, MI.unlink_target(~K, ~V, ~cmp, MI.delete_target(~K, ~V, ~cmp, id, MI.read(~K, ~V, ~cmp, m1, id)))), unlink_target_s(~K, ~V, ~cmp, MI.delete_target(~K, ~V, ~cmp, id, MI.read(~K, ~V, ~cmp, m1, id)), delete_target_g(~K, ~V, ~cmp, id, MI.read(~K, ~V, ~cmp, m1, id), read_g(~K, ~V, ~cmp, m1, id, g_pair_result)))) : {(_, value) == MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.remove_present_1(~K, ~V, ~cmp, id, Tuple{m1, value})) : M.TreeMap<K, V, cmp> & Maybe<&2, V>}
      {==}


def remove_present_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, V>, MI.remove_present(~K, ~V, ~cmp, m, id)) == True{} : Bool}:
  remove_present_1_g(~K, ~V, ~cmp, id, MI.exchange(~K, ~V, ~cmp, m, id, None{}), exchange_g(~K, ~V, ~cmp, m, id, None{}, g_m))

def remove_present_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.remove_present(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id) == MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.remove_present(~K, ~V, ~cmp, m, id)) : M.TreeMap<K, V, cmp> & Maybe<&2, V>}:
  %Equal.sym(M.TreeMap<K, V, cmp> & Maybe<&2, V>, M.exchange(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id, None{}), MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.exchange(~K, ~V, ~cmp, m, id, None{})), exchange_s(~K, ~V, ~cmp, m, id, None{}, g_m)) : {M.remove_present_1(~K, ~V, ~cmp, id, _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.remove_present(~K, ~V, ~cmp, m, id)) : M.TreeMap<K, V, cmp> & Maybe<&2, V>}
  remove_present_1_s(~K, ~V, ~cmp, id, MI.exchange(~K, ~V, ~cmp, m, id, None{}), exchange_g(~K, ~V, ~cmp, m, id, None{}, g_m))


def remove_id_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, V>, MI.remove_id(~K, ~V, ~cmp, m, id)) == True{} : Bool}:
  match id:
    case 0n:
      g_m
    case 1n+ +px2:
      remove_present_g(~K, ~V, ~cmp, m, 1n+px2, g_m)

def remove_id_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.remove_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id) == MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.remove_id(~K, ~V, ~cmp, m, id)) : M.TreeMap<K, V, cmp> & Maybe<&2, V>}:
  match id:
    case 0n:
      {==}
    case 1n+ +px2:
      remove_present_s(~K, ~V, ~cmp, m, 1n+px2, g_m)


def remove_found_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh<K, V> & M.Search, +g_r: {MI.dgp(K, V, M.Search, r) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, V>, MI.remove_found(~K, ~V, ~cmp, r)) == True{} : Bool}:
  match r:
    case Tuple{+m, M.Search{+id, +p, +on_left}}:
      remove_id_g(~K, ~V, ~cmp, m, id, g_r)

def remove_found_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh<K, V> & M.Search, +g_r: {MI.dgp(K, V, M.Search, r) == True{} : Bool}) -> {M.remove_found(~K, ~V, ~cmp, MI.rp(~K, ~V, ~cmp, M.Search, r)) == MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.remove_found(~K, ~V, ~cmp, r)) : M.TreeMap<K, V, cmp> & Maybe<&2, V>}:
  match r:
    case Tuple{+m, M.Search{+id, +p, +on_left}}:
      remove_id_s(~K, ~V, ~cmp, m, id, g_r)


def remove_entry_id_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, M.Entry<K, V>>, MI.remove_entry_id_1(~K, ~V, ~cmp, id, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m1, +node}:
      entry_value_g(~K, ~V, ~cmp, M.node_key(~K, node), MI.remove_id(~K, ~V, ~cmp, m1, id), remove_id_g(~K, ~V, ~cmp, m1, id, g_pair_result))

def remove_entry_id_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +id: Nat, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.remove_entry_id_1(~K, ~V, ~cmp, id, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.remove_entry_id_1(~K, ~V, ~cmp, id, pair_result)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
  match pair_result:
    case Tuple{+m1, +node}:
      %Equal.sym(M.TreeMap<K, V, cmp> & Maybe<&2, V>, M.remove_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m1), id), MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.remove_id(~K, ~V, ~cmp, m1, id)), remove_id_s(~K, ~V, ~cmp, m1, id, g_pair_result)) : {M.entry_value(~K, ~V, ~cmp, M.node_key(~K, node), _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.remove_entry_id_1(~K, ~V, ~cmp, id, Tuple{m1, node})) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
      entry_value_s(~K, ~V, ~cmp, M.node_key(~K, node), MI.remove_id(~K, ~V, ~cmp, m1, id), remove_id_g(~K, ~V, ~cmp, m1, id, g_pair_result))


def iterator_delete_1_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +current: Nat, +lower: M.Bound<K>, +upper: M.Bound<K>, +forward: Bool, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {MI.dgcp(K, V, Maybe<&2, V>, MI.iterator_delete_1(~K, ~V, ~cmp, current, lower, upper, forward, pair_result)) == True{} : Bool}:
  match pair_result:
    case Tuple{+m1, +node}:
      iterator_reseek_g(~K, ~V, ~cmp, M.node_key(~K, node), lower, upper, forward, MI.remove_id(~K, ~V, ~cmp, m1, current), remove_id_g(~K, ~V, ~cmp, m1, current, g_pair_result))

def iterator_delete_1_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +current: Nat, +lower: M.Bound<K>, +upper: M.Bound<K>, +forward: Bool, pair_result: ST.Sh<K, V> & M.Node<K>, +g_pair_result: {MI.dgp(K, V, M.Node<K>, pair_result) == True{} : Bool}) -> {M.iterator_delete_1(~K, ~V, ~cmp, current, lower, upper, forward, MI.rp(~K, ~V, ~cmp, M.Node<K>, pair_result)) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, V>, MI.iterator_delete_1(~K, ~V, ~cmp, current, lower, upper, forward, pair_result)) : M.Cursor<K, V, cmp> & Maybe<&2, V>}:
  match pair_result:
    case Tuple{+m1, +node}:
      %Equal.sym(M.TreeMap<K, V, cmp> & Maybe<&2, V>, M.remove_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m1), current), MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.remove_id(~K, ~V, ~cmp, m1, current)), remove_id_s(~K, ~V, ~cmp, m1, current, g_pair_result)) : {M.iterator_reseek(~K, ~V, ~cmp, M.node_key(~K, node), lower, upper, forward, _) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, V>, MI.iterator_delete_1(~K, ~V, ~cmp, current, lower, upper, forward, Tuple{m1, node})) : M.Cursor<K, V, cmp> & Maybe<&2, V>}
      iterator_reseek_s(~K, ~V, ~cmp, M.node_key(~K, node), lower, upper, forward, MI.remove_id(~K, ~V, ~cmp, m1, current), remove_id_g(~K, ~V, ~cmp, m1, current, g_pair_result))


def remove_if_apply_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +replacement: V, +equal: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Bool, MI.remove_if_apply(~K, ~V, ~cmp, m, id, replacement, equal)) == True{} : Bool}:
  match equal:
    case False{}:
      g_m
    case True{}:
      changed_value_g(~K, ~V, ~cmp, MI.remove_id(~K, ~V, ~cmp, m, id), remove_id_g(~K, ~V, ~cmp, m, id, g_m))

def remove_if_apply_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +replacement: V, +equal: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.remove_if_apply(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id, replacement, equal) == MI.rp(~K, ~V, ~cmp, Bool, MI.remove_if_apply(~K, ~V, ~cmp, m, id, replacement, equal)) : M.TreeMap<K, V, cmp> & Bool}:
  match equal:
    case False{}:
      {==}
    case True{}:
      %Equal.sym(M.TreeMap<K, V, cmp> & Maybe<&2, V>, M.remove_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id), MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.remove_id(~K, ~V, ~cmp, m, id)), remove_id_s(~K, ~V, ~cmp, m, id, g_m)) : {M.changed_value(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Bool, MI.remove_if_apply(~K, ~V, ~cmp, m, id, replacement, True{})) : M.TreeMap<K, V, cmp> & Bool}
      changed_value_s(~K, ~V, ~cmp, MI.remove_id(~K, ~V, ~cmp, m, id), remove_id_g(~K, ~V, ~cmp, m, id, g_m))


def remove_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, V>, MI.remove(~K, ~V, ~cmp, m, k)) == True{} : Bool}:
  remove_found_g(~K, ~V, ~cmp, MI.search(~K, ~V, ~cmp, m, k), search_g(~K, ~V, ~cmp, m, k, g_m))

def remove_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.remove(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k) == MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.remove(~K, ~V, ~cmp, m, k)) : M.TreeMap<K, V, cmp> & Maybe<&2, V>}:
  %Equal.sym(M.TreeMap<K, V, cmp> & M.Search, M.search(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k), MI.rp(~K, ~V, ~cmp, M.Search, MI.search(~K, ~V, ~cmp, m, k)), search_s(~K, ~V, ~cmp, m, k, g_m)) : {M.remove_found(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.remove(~K, ~V, ~cmp, m, k)) : M.TreeMap<K, V, cmp> & Maybe<&2, V>}
  remove_found_s(~K, ~V, ~cmp, MI.search(~K, ~V, ~cmp, m, k), search_g(~K, ~V, ~cmp, m, k, g_m))


def remove_entry_id_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, M.Entry<K, V>>, MI.remove_entry_id(~K, ~V, ~cmp, m, id)) == True{} : Bool}:
  remove_entry_id_1_g(~K, ~V, ~cmp, id, MI.read(~K, ~V, ~cmp, m, id), read_g(~K, ~V, ~cmp, m, id, g_m))

def remove_entry_id_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +id: Nat, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.remove_entry_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.remove_entry_id(~K, ~V, ~cmp, m, id)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
  %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m, id)), read_s(~K, ~V, ~cmp, m, id, g_m)) : {M.remove_entry_id_1(~K, ~V, ~cmp, id, _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.remove_entry_id(~K, ~V, ~cmp, m, id)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
  remove_entry_id_1_s(~K, ~V, ~cmp, id, MI.read(~K, ~V, ~cmp, m, id), read_g(~K, ~V, ~cmp, m, id, g_m))


def iterator_delete_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +next: Nat, +current: Nat, +lower: M.Bound<K>, +upper: M.Bound<K>, +forward: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgcp(K, V, Maybe<&2, V>, MI.iterator_delete(~K, ~V, ~cmp, m, next, current, lower, upper, forward)) == True{} : Bool}:
  iterator_delete_1_g(~K, ~V, ~cmp, current, lower, upper, forward, MI.read(~K, ~V, ~cmp, m, next), read_g(~K, ~V, ~cmp, m, next, g_m))

def iterator_delete_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +next: Nat, +current: Nat, +lower: M.Bound<K>, +upper: M.Bound<K>, +forward: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.iterator_delete(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), next, current, lower, upper, forward) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, V>, MI.iterator_delete(~K, ~V, ~cmp, m, next, current, lower, upper, forward)) : M.Cursor<K, V, cmp> & Maybe<&2, V>}:
  %Equal.sym(M.TreeMap<K, V, cmp> & M.Node<K>, M.read(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), next), MI.rp(~K, ~V, ~cmp, M.Node<K>, MI.read(~K, ~V, ~cmp, m, next)), read_s(~K, ~V, ~cmp, m, next, g_m)) : {M.iterator_delete_1(~K, ~V, ~cmp, current, lower, upper, forward, _) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, V>, MI.iterator_delete(~K, ~V, ~cmp, m, next, current, lower, upper, forward)) : M.Cursor<K, V, cmp> & Maybe<&2, V>}
  iterator_delete_1_s(~K, ~V, ~cmp, current, lower, upper, forward, MI.read(~K, ~V, ~cmp, m, next), read_g(~K, ~V, ~cmp, m, next, g_m))


def remove_if_value_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~eq: V -> V -> Bool, +id: Nat, +expected: V, +replacement: V, r: ST.Sh<K, V> & Maybe<&2, V>, +g_r: {MI.dgp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {MI.dgp(K, V, Bool, MI.remove_if_value(~K, ~V, ~cmp, ~eq, id, expected, replacement, r)) == True{} : Bool}:
  match r:
    case Tuple{+px2, None{}}:
      g_r
    case Tuple{+px2, Some{+px4}}:
      remove_if_apply_g(~K, ~V, ~cmp, px2, id, replacement, eq(px4, expected), g_r)

def remove_if_value_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~eq: V -> V -> Bool, +id: Nat, +expected: V, +replacement: V, r: ST.Sh<K, V> & Maybe<&2, V>, +g_r: {MI.dgp(K, V, Maybe<&2, V>, r) == True{} : Bool}) -> {M.remove_if_value(~K, ~V, ~cmp, ~eq, id, expected, replacement, MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, r)) == MI.rp(~K, ~V, ~cmp, Bool, MI.remove_if_value(~K, ~V, ~cmp, ~eq, id, expected, replacement, r)) : M.TreeMap<K, V, cmp> & Bool}:
  match r:
    case Tuple{+px2, None{}}:
      {==}
    case Tuple{+px2, Some{+px4}}:
      remove_if_apply_s(~K, ~V, ~cmp, px2, id, replacement, eq(px4, expected), g_r)


def poll_ready_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh<K, V> & Nat, +g_r: {MI.dgp(K, V, Nat, r) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, M.Entry<K, V>>, MI.poll_ready(~K, ~V, ~cmp, r)) == True{} : Bool}:
  match r:
    case Tuple{+m, +id}:
      remove_entry_id_g(~K, ~V, ~cmp, m, id, g_r)

def poll_ready_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, r: ST.Sh<K, V> & Nat, +g_r: {MI.dgp(K, V, Nat, r) == True{} : Bool}) -> {M.poll_ready(~K, ~V, ~cmp, MI.rp(~K, ~V, ~cmp, Nat, r)) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.poll_ready(~K, ~V, ~cmp, r)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
  match r:
    case Tuple{+m, +id}:
      remove_entry_id_s(~K, ~V, ~cmp, m, id, g_r)


def view_remove_checked_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +lower: M.Bound<K>, +upper: M.Bound<K>, +descending: Bool, +valid: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgvp(K, V, Maybe<&2, V>, MI.view_remove_checked(~K, ~V, ~cmp, m, k, lower, upper, descending, valid)) == True{} : Bool}:
  match valid:
    case True{}:
      view_value_g(~K, ~V, ~cmp, lower, upper, descending, MI.remove(~K, ~V, ~cmp, m, k), remove_g(~K, ~V, ~cmp, m, k, g_m))
    case False{}:
      g_m

def view_remove_checked_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +k: K, +lower: M.Bound<K>, +upper: M.Bound<K>, +descending: Bool, +valid: Bool, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.view_remove_checked(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k, lower, upper, descending, valid) == MI.rvp(~K, ~V, ~cmp, Maybe<&2, V>, MI.view_remove_checked(~K, ~V, ~cmp, m, k, lower, upper, descending, valid)) : M.View<K, V, cmp> & Maybe<&2, V>}:
  match valid:
    case True{}:
      %Equal.sym(M.TreeMap<K, V, cmp> & Maybe<&2, V>, M.remove(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k), MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.remove(~K, ~V, ~cmp, m, k)), remove_s(~K, ~V, ~cmp, m, k, g_m)) : {M.view_value(~K, ~V, ~cmp, lower, upper, descending, _) == MI.rvp(~K, ~V, ~cmp, Maybe<&2, V>, MI.view_remove_checked(~K, ~V, ~cmp, m, k, lower, upper, descending, True{})) : M.View<K, V, cmp> & Maybe<&2, V>}
      view_value_s(~K, ~V, ~cmp, lower, upper, descending, MI.remove(~K, ~V, ~cmp, m, k), remove_g(~K, ~V, ~cmp, m, k, g_m))
    case False{}:
      {==}


def iterator_remove_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +cursor: MI.MCursor<K, V>, +g_cursor: {MI.dgc(K, V, cursor) == True{} : Bool}) -> {MI.dgcp(K, V, Maybe<&2, V>, MI.iterator_remove(~K, ~V, ~cmp, cursor)) == True{} : Bool}:
  match cursor:
    case MI.MC{+m, +next, +current, +lower, +upper, +forward}:
      iterator_delete_g(~K, ~V, ~cmp, m, next, current, lower, upper, forward, g_cursor)

def iterator_remove_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +cursor: MI.MCursor<K, V>, +g_cursor: {MI.dgc(K, V, cursor) == True{} : Bool}) -> {M.iterator_remove(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, cursor)) == MI.rcp(~K, ~V, ~cmp, Maybe<&2, V>, MI.iterator_remove(~K, ~V, ~cmp, cursor)) : M.Cursor<K, V, cmp> & Maybe<&2, V>}:
  match cursor:
    case MI.MC{+m, +next, +current, +lower, +upper, +forward}:
      iterator_delete_s(~K, ~V, ~cmp, m, next, current, lower, upper, forward, g_cursor)


def remove_if_found_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~eq: V -> V -> Bool, +expected: V, +replacement: V, r: ST.Sh<K, V> & M.Search, +g_r: {MI.dgp(K, V, M.Search, r) == True{} : Bool}) -> {MI.dgp(K, V, Bool, MI.remove_if_found(~K, ~V, ~cmp, ~eq, expected, replacement, r)) == True{} : Bool}:
  match r:
    case Tuple{+m, M.Search{+id, +p, +on_left}}:
      remove_if_value_g(~K, ~V, ~cmp, ~eq, id, expected, replacement, MI.get_id(~K, ~V, ~cmp, m, id), get_id_g(~K, ~V, ~cmp, m, id, g_r))

def remove_if_found_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~eq: V -> V -> Bool, +expected: V, +replacement: V, r: ST.Sh<K, V> & M.Search, +g_r: {MI.dgp(K, V, M.Search, r) == True{} : Bool}) -> {M.remove_if_found(~K, ~V, ~cmp, ~eq, expected, replacement, MI.rp(~K, ~V, ~cmp, M.Search, r)) == MI.rp(~K, ~V, ~cmp, Bool, MI.remove_if_found(~K, ~V, ~cmp, ~eq, expected, replacement, r)) : M.TreeMap<K, V, cmp> & Bool}:
  match r:
    case Tuple{+m, M.Search{+id, +p, +on_left}}:
      %Equal.sym(M.TreeMap<K, V, cmp> & Maybe<&2, V>, M.get_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), id), MI.rp(~K, ~V, ~cmp, Maybe<&2, V>, MI.get_id(~K, ~V, ~cmp, m, id)), get_id_s(~K, ~V, ~cmp, m, id, g_r)) : {M.remove_if_value(~K, ~V, ~cmp, ~eq, id, expected, replacement, _) == MI.rp(~K, ~V, ~cmp, Bool, MI.remove_if_found(~K, ~V, ~cmp, ~eq, expected, replacement, Tuple{m, M.Search{id, p, on_left}})) : M.TreeMap<K, V, cmp> & Bool}
      remove_if_value_s(~K, ~V, ~cmp, ~eq, id, expected, replacement, MI.get_id(~K, ~V, ~cmp, m, id), get_id_g(~K, ~V, ~cmp, m, id, g_r))


def poll_first_entry_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, M.Entry<K, V>>, MI.poll_first_entry(~K, ~V, ~cmp, m)) == True{} : Bool}:
  poll_ready_g(~K, ~V, ~cmp, MI.first_id(~K, ~V, ~cmp, m), first_id_g(~K, ~V, ~cmp, m, g_m))

def poll_first_entry_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.poll_first_entry(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.poll_first_entry(~K, ~V, ~cmp, m)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
  %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.first_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)), MI.rp(~K, ~V, ~cmp, Nat, MI.first_id(~K, ~V, ~cmp, m)), first_id_s(~K, ~V, ~cmp, m, g_m)) : {M.poll_ready(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.poll_first_entry(~K, ~V, ~cmp, m)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
  poll_ready_s(~K, ~V, ~cmp, MI.first_id(~K, ~V, ~cmp, m), first_id_g(~K, ~V, ~cmp, m, g_m))


def poll_last_entry_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Maybe<&2, M.Entry<K, V>>, MI.poll_last_entry(~K, ~V, ~cmp, m)) == True{} : Bool}:
  poll_ready_g(~K, ~V, ~cmp, MI.last_id(~K, ~V, ~cmp, m), last_id_g(~K, ~V, ~cmp, m, g_m))

def poll_last_entry_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +m: ST.Sh<K, V>, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.poll_last_entry(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.poll_last_entry(~K, ~V, ~cmp, m)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}:
  %Equal.sym(M.TreeMap<K, V, cmp> & Nat, M.last_id(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m)), MI.rp(~K, ~V, ~cmp, Nat, MI.last_id(~K, ~V, ~cmp, m)), last_id_s(~K, ~V, ~cmp, m, g_m)) : {M.poll_ready(~K, ~V, ~cmp, _) == MI.rp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.poll_last_entry(~K, ~V, ~cmp, m)) : M.TreeMap<K, V, cmp> & Maybe<&2, M.Entry<K, V>>}
  poll_ready_s(~K, ~V, ~cmp, MI.last_id(~K, ~V, ~cmp, m), last_id_g(~K, ~V, ~cmp, m, g_m))


def view_remove_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +k: K, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {MI.dgvp(K, V, Maybe<&2, V>, MI.view_remove(~K, ~V, ~cmp, view, k)) == True{} : Bool}:
  match view:
    case MI.MV{+m, +lower, +upper, +descending}:
      view_remove_checked_g(~K, ~V, ~cmp, m, k, lower, upper, descending, M.in_range(~K, ~V, ~cmp, k, lower, upper), g_view)

def view_remove_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +k: K, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {M.view_remove(~K, ~V, ~cmp, MI.rv(~K, ~V, ~cmp, view), k) == MI.rvp(~K, ~V, ~cmp, Maybe<&2, V>, MI.view_remove(~K, ~V, ~cmp, view, k)) : M.View<K, V, cmp> & Maybe<&2, V>}:
  match view:
    case MI.MV{+m, +lower, +upper, +descending}:
      view_remove_checked_s(~K, ~V, ~cmp, m, k, lower, upper, descending, M.in_range(~K, ~V, ~cmp, k, lower, upper), g_view)


def remove_if_equal_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~eq: V -> V -> Bool, +m: ST.Sh<K, V>, +k: K, +expected: V, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {MI.dgp(K, V, Bool, MI.remove_if_equal(~K, ~V, ~cmp, ~eq, m, k, expected)) == True{} : Bool}:
  remove_if_found_g(~K, ~V, ~cmp, ~eq, expected, expected, MI.search(~K, ~V, ~cmp, m, k), search_g(~K, ~V, ~cmp, m, k, g_m))

def remove_if_equal_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, ~eq: V -> V -> Bool, +m: ST.Sh<K, V>, +k: K, +expected: V, +g_m: {MI.dg(K, V, m) == True{} : Bool}) -> {M.remove_if_equal(~K, ~V, ~cmp, ~eq, ST.real(~K, ~V, ~cmp, m), k, expected) == MI.rp(~K, ~V, ~cmp, Bool, MI.remove_if_equal(~K, ~V, ~cmp, ~eq, m, k, expected)) : M.TreeMap<K, V, cmp> & Bool}:
  %Equal.sym(M.TreeMap<K, V, cmp> & M.Search, M.search(~K, ~V, ~cmp, ST.real(~K, ~V, ~cmp, m), k), MI.rp(~K, ~V, ~cmp, M.Search, MI.search(~K, ~V, ~cmp, m, k)), search_s(~K, ~V, ~cmp, m, k, g_m)) : {M.remove_if_found(~K, ~V, ~cmp, ~eq, expected, expected, _) == MI.rp(~K, ~V, ~cmp, Bool, MI.remove_if_equal(~K, ~V, ~cmp, ~eq, m, k, expected)) : M.TreeMap<K, V, cmp> & Bool}
  remove_if_found_s(~K, ~V, ~cmp, ~eq, expected, expected, MI.search(~K, ~V, ~cmp, m, k), search_g(~K, ~V, ~cmp, m, k, g_m))


def view_clear_loop_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +fuel: Nat, st: MI.MCursor<K, V> & Maybe<&2, M.Entry<K, V>>, +g_st: {MI.dgcp(K, V, Maybe<&2, M.Entry<K, V>>, st) == True{} : Bool}) -> {MI.dgv(K, V, MI.view_clear_loop(~K, ~V, ~cmp, fuel, st)) == True{} : Bool}:
  match fuel st:
    case 0n Tuple{+px4, None{}}:
      iterator_view_g(~K, ~V, ~cmp, px4, g_st)
    case 0n Tuple{+px4, Some{+px6}}:
      iterator_view_g(~K, ~V, ~cmp, px4, g_st)
    case 1n+ +px3 Tuple{+px7, None{}}:
      iterator_view_g(~K, ~V, ~cmp, px7, g_st)
    case 1n+ +px3 Tuple{+px7, Some{+px9}}:
      view_clear_loop_g(~K, ~V, ~cmp, px3, MI.view_clear_next(~K, ~V, ~cmp, MI.iterator_remove(~K, ~V, ~cmp, px7)), view_clear_next_g(~K, ~V, ~cmp, MI.iterator_remove(~K, ~V, ~cmp, px7), iterator_remove_g(~K, ~V, ~cmp, px7, g_st)))

def view_clear_loop_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +fuel: Nat, st: MI.MCursor<K, V> & Maybe<&2, M.Entry<K, V>>, +g_st: {MI.dgcp(K, V, Maybe<&2, M.Entry<K, V>>, st) == True{} : Bool}) -> {M.view_clear_loop(~K, ~V, ~cmp, fuel, MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, st)) == MI.rv(~K, ~V, ~cmp, MI.view_clear_loop(~K, ~V, ~cmp, fuel, st)) : M.View<K, V, cmp>}:
  match fuel st:
    case 0n Tuple{+px4, None{}}:
      iterator_view_s(~K, ~V, ~cmp, px4, g_st)
    case 0n Tuple{+px4, Some{+px6}}:
      iterator_view_s(~K, ~V, ~cmp, px4, g_st)
    case 1n+ +px3 Tuple{+px7, None{}}:
      iterator_view_s(~K, ~V, ~cmp, px7, g_st)
    case 1n+ +px3 Tuple{+px7, Some{+px9}}:
      %Equal.sym(M.Cursor<K, V, cmp> & Maybe<&2, V>, M.iterator_remove(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, px7)), MI.rcp(~K, ~V, ~cmp, Maybe<&2, V>, MI.iterator_remove(~K, ~V, ~cmp, px7)), iterator_remove_s(~K, ~V, ~cmp, px7, g_st)) : {M.view_clear_loop(~K, ~V, ~cmp, px3, M.view_clear_next(~K, ~V, ~cmp, _)) == MI.rv(~K, ~V, ~cmp, MI.view_clear_loop(~K, ~V, ~cmp, 1n+ px3, Tuple{px7, Some{px9}})) : M.View<K, V, cmp>}
      %Equal.sym(M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>, M.view_clear_next(~K, ~V, ~cmp, MI.rcp(~K, ~V, ~cmp, Maybe<&2, V>, MI.iterator_remove(~K, ~V, ~cmp, px7))), MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.view_clear_next(~K, ~V, ~cmp, MI.iterator_remove(~K, ~V, ~cmp, px7))), view_clear_next_s(~K, ~V, ~cmp, MI.iterator_remove(~K, ~V, ~cmp, px7), iterator_remove_g(~K, ~V, ~cmp, px7, g_st))) : {M.view_clear_loop(~K, ~V, ~cmp, px3, _) == MI.rv(~K, ~V, ~cmp, MI.view_clear_loop(~K, ~V, ~cmp, 1n+ px3, Tuple{px7, Some{px9}})) : M.View<K, V, cmp>}
      view_clear_loop_s(~K, ~V, ~cmp, px3, MI.view_clear_next(~K, ~V, ~cmp, MI.iterator_remove(~K, ~V, ~cmp, px7)), view_clear_next_g(~K, ~V, ~cmp, MI.iterator_remove(~K, ~V, ~cmp, px7), iterator_remove_g(~K, ~V, ~cmp, px7, g_st)))


def view_clear_g(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {MI.dgv(K, V, MI.view_clear(~K, ~V, ~cmp, view)) == True{} : Bool}:
  match view:
    case MI.MV{ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}, +lower, +upper, +descending}:
      view_clear_loop_g(~K, ~V, ~cmp, 1n+n, MI.iterator_next(~K, ~V, ~cmp, MI.view_iterator(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending})), iterator_next_g(~K, ~V, ~cmp, MI.view_iterator(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending}), view_iterator_g(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending}, g_view)))

def view_clear_s(~K: Data, ~V: Data, ~cmp: K -> K -> Cmp, +view: MI.MView<K, V>, +g_view: {MI.dgv(K, V, view) == True{} : Bool}) -> {M.view_clear(~K, ~V, ~cmp, MI.rv(~K, ~V, ~cmp, view)) == MI.rv(~K, ~V, ~cmp, MI.view_clear(~K, ~V, ~cmp, view)) : M.View<K, V, cmp>}:
  match view:
    case MI.MV{ST.SH{+n, +root, +lo, +hi, +free, +l_0, +d_0, +nl_0, +pl_0, +t_0, +fl_0}, +lower, +upper, +descending}:
      %Equal.sym(M.Cursor<K, V, cmp>, M.view_iterator(~K, ~V, ~cmp, M.View{ST.real(~K, ~V, ~cmp, ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}), lower, upper, descending}), MI.rc(~K, ~V, ~cmp, MI.view_iterator(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending})), view_iterator_s(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending}, g_view)) : {M.view_clear_loop(~K, ~V, ~cmp, 1n+n, M.iterator_next(~K, ~V, ~cmp, _)) == MI.rv(~K, ~V, ~cmp, MI.view_clear(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending})) : M.View<K, V, cmp>}
      %Equal.sym(M.Cursor<K, V, cmp> & Maybe<&2, M.Entry<K, V>>, M.iterator_next(~K, ~V, ~cmp, MI.rc(~K, ~V, ~cmp, MI.view_iterator(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending}))), MI.rcp(~K, ~V, ~cmp, Maybe<&2, M.Entry<K, V>>, MI.iterator_next(~K, ~V, ~cmp, MI.view_iterator(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending}))), iterator_next_s(~K, ~V, ~cmp, MI.view_iterator(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending}), view_iterator_g(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending}, g_view))) : {M.view_clear_loop(~K, ~V, ~cmp, 1n+n, _) == MI.rv(~K, ~V, ~cmp, MI.view_clear(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending})) : M.View<K, V, cmp>}
      view_clear_loop_s(~K, ~V, ~cmp, 1n+n, MI.iterator_next(~K, ~V, ~cmp, MI.view_iterator(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending})), iterator_next_g(~K, ~V, ~cmp, MI.view_iterator(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending}), view_iterator_g(~K, ~V, ~cmp, MI.MV{ST.SH{n, root, lo, hi, free, l_0, d_0, nl_0, pl_0, t_0, fl_0}, lower, upper, descending}, g_view)))