// Extra functions on vectors
module ck/vectorck/vector

import std/core/undivstd/core/undiv

// Note: `@unsafe-vector` is introduced in Koka v3.1.3.

// Unsafe function.
// This function is an internal function in the standard library.
// See <https://koka-lang.github.io/koka/doc/std_core_vector.html>
inline extern unsafe-vectorck/vector/unsafe-vector: forall<a> (n : ssize_t) -> vector<a>(n: ssize_tstd/core/types/ssize_t: V): totalstd/core/types/total: E vectorstd/core/types/vector: V -> V<aa: V>
  c inline "kk_vector_alloc(#1, kk_box_null(), kk_context())"

// Unsafe function.
// This function is an internal function in the standard library.
// See <https://koka-lang.github.io/koka/doc/std_core_vector.html>
inline extern unsafe-idxck/vector/unsafe-idx: forall<a> (v : vector<a>, index : ssize_t) -> a(^v: vectorstd/core/types/vector: V -> V<aa: V>, index: ssize_tstd/core/types/ssize_t: V): totalstd/core/types/total: E aa: V
  c "kk_vector_at_borrow"

// Unsafe function.
// This function is an internal function in the standard library.
// See <https://koka-lang.github.io/koka/doc/std_core_vector.html>
inline extern unsafe-assignck/vector/unsafe-assign: forall<a> (v : vector<a>, index : ssize_t, value : a) -> ()(v: vectorstd/core/types/vector: V -> V<aa: V>, index: ssize_tstd/core/types/ssize_t: V, value: aa: V): totalstd/core/types/total: E (std/core/types/unit: V)std/core/types/unit: V
  c "kk_vector_unsafe_assign"

/// Implementation notes of sort:
/// - The implementation is merge sort.
/// - It is 2 times faster than when we do not use unsafe-* functions.

// Stable sort
pub fun sortck/vector/sort: forall<a,e> (v : vector<a>, @implicit/(<) : (a, a) -> <pure|e> bool) -> <pure|e> vector<a>(vv: vector<$85>: vectorstd/core/types/vector: V -> V<aa: V>, (@implicit/<)?(<): ($85, $85) -> <pure|$86> bool: (aa: V, aa: V) -> <purestd/core/pure: E|ee: E> boolstd/core/types/bool: V)result: -> <pure|1148> vector<1147>: <purestd/core/pure: E|ee: E> vectorstd/core/types/vector: V -> V<aa: V>
  var resres: local-var<$96,vector<$85>> := vv: vector<$85>
  var temptemp: local-var<$96,vector<$85>> := unsafe-vectorck/vector/unsafe-vector: (n : ssize_t) -> <div,exn,local<$96>|$86> vector<$85>((vv: vector<$85>.lengthstd/core/vector/length: (v : vector<$85>) -> <div,exn,local<$96>|$86> int /std/core/int/(/): (x : int, y : int) -> <div,exn,local<$96>|$86> int 2literal: int
dec  = 2
hex8 = 0x02
bit8 = 0b00000010).ssize_tstd/core/int/ssize_t: (i : int) -> <div,exn,local<$96>|$86> ssize_t)
  var pp: local-var<$96,int> := 0literal: int
dec  = 0
hex8 = 0x00
bit8 = 0b00000000
  var l1l1: local-var<$96,int> := 0literal: int
dec  = 0
hex8 = 0x00
bit8 = 0b00000000
  var l2l2: local-var<$96,int> := 0literal: int
dec  = 0
hex8 = 0x00
bit8 = 0b00000000

  fun looploop: (l : int, r : int) -> <pure,local<$96>|$86> ()(ll: int: intstd/core/types/int: V, rr: int: intstd/core/types/int: V)result: -> <div,exn,local<$96>|$86> ()
    if rr: int -std/core/int/(-): (x : int, y : int) -> <div,exn,local<$96>|$86> int ll: int <=std/core/int/(<=): (x : int, y : int) -> <div,exn,local<$96>|$86> bool 1literal: int
dec  = 1
hex8 = 0x01
bit8 = 0b00000001 then
      returnreturn: () (std/core/types/Unit: ())std/core/types/Unit: ()

    val mm: int = (ll: int +std/core/int/(+): (x : int, y : int) -> <div,exn,local<$96>|$86> int rr: int) /std/core/int/(/): (x : int, y : int) -> <div,exn,local<$96>|$86> int 2literal: int
dec  = 2
hex8 = 0x02
bit8 = 0b00000010
    looploop: (l : int, r : int) -> <div,exn,local<$96>|$86> ()(ll: int.pretend-decreasingstd/core/undiv/pretend-decreasing: (x : int) -> <div,exn,local<$96>|$86> int, mm: int)
    looploop: (l : int, r : int) -> <div,exn,local<$96>|$86> ()(mm: int.pretend-decreasingstd/core/undiv/pretend-decreasing: (x : int) -> <div,exn,local<$96>|$86> int, rr: int)

    forstd/core/range/for: (start : int, end : int, action : (int) -> <local<$96>,div,exn|$86> ()) -> <local<$96>,div,exn|$86> ()(ll: int, mm: int -std/core/int/(-): (x : int, y : int) -> <local<$96>,div,exn|$86> int 1literal: int
dec  = 1
hex8 = 0x01
bit8 = 0b00000001) fnfn: (i : int) -> <local<$96>,div,exn|$86> ()(ii: int)
      temptemp: vector<$85>
?hdiv=iev@301.unsafe-assignck/vector/unsafe-assign: (v : vector<$85>, index : ssize_t, value : $85) -> <local<$96>,div,exn|$86> ()((ii: int -std/core/int/(-): (x : int, y : int) -> <local<$96>,div,exn|$86> int ll: int).ssize_tstd/core/int/ssize_t: (i : int) -> <local<$96>,div,exn|$86> ssize_t, resres: vector<$85>
?hdiv=iev@332.unsafe-idxck/vector/unsafe-idx: (v : vector<$85>, index : ssize_t) -> <local<$96>,div,exn|$86> $85(ii: int.ssize_tstd/core/int/ssize_t: (i : int) -> <local<$96>,div,exn|$86> ssize_t))

    pp: local-var<$96,int> :=std/core/types/local-set: (v : local-var<$96,int>, assigned : int) -> <local<$96>,div,exn|$86> () ll: int
    l1l1: local-var<$96,int> :=std/core/types/local-set: (v : local-var<$96,int>, assigned : int) -> <local<$96>,div,exn|$86> () ll: int
    l2l2: local-var<$96,int> :=std/core/types/local-set: (v : local-var<$96,int>, assigned : int) -> <local<$96>,div,exn|$86> () mm: int
    whilestd/core/while: (predicate : () -> <div,local<$96>,exn|$86> bool, action : () -> <div,local<$96>,exn|$86> ()) -> <div,local<$96>,exn|$86> () { l1l1: int
?hdiv=iev@401 <std/core/int/(<): (x : int, y : int) -> <local<$96>,div,exn|$86> bool mm: int &&std/core/types/(&&): (x : bool, y : bool) -> <local<$96>,div,exn|$86> bool l2l2: int
?hdiv=iev@449 <std/core/int/(<): (x : int, y : int) -> <local<$96>,div,exn|$86> bool rr: int }
      val v1v1: $85 = temptemp: vector<$85>
?hdiv=iev@506.unsafe-idxck/vector/unsafe-idx: (v : vector<$85>, index : ssize_t) -> <local<$96>,div,exn|$86> $85((l1l1: int
?hdiv=iev@528 -std/core/int/(-): (x : int, y : int) -> <local<$96>,div,exn|$86> int ll: int).ssize_tstd/core/int/ssize_t: (i : int) -> <local<$96>,div,exn|$86> ssize_t)
      val v2v2: $85 = resres: vector<$85>
?hdiv=iev@550.unsafe-idxck/vector/unsafe-idx: (v : vector<$85>, index : ssize_t) -> <local<$96>,div,exn|$86> $85(l2l2: int
?hdiv=iev@568.ssize_tstd/core/int/ssize_t: (i : int) -> <local<$96>,div,exn|$86> ssize_t)
      if mask<local_1: H>{ v2v2: $85 <?(<): ($85, $85) -> <pure|$86> bool v1v1: $85 } then
        resres: vector<$85>
?hdiv=iev@630.unsafe-assignck/vector/unsafe-assign: (v : vector<$85>, index : ssize_t, value : $85) -> <local<$96>,div,exn|$86> ()(pp: int
?hdiv=iev@648.ssize_tstd/core/int/ssize_t: (i : int) -> <local<$96>,div,exn|$86> ssize_t, resres: vector<$85>
?hdiv=iev@669.unsafe-idxck/vector/unsafe-idx: (v : vector<$85>, index : ssize_t) -> <local<$96>,div,exn|$86> $85(l2l2: int
?hdiv=iev@687.ssize_tstd/core/int/ssize_t: (i : int) -> <local<$96>,div,exn|$86> ssize_t))
        l2l2: local-var<$96,int> :=std/core/types/local-set: (v : local-var<$96,int>, assigned : int) -> <local<$96>,div,exn|$86> () l2l2: int
?hdiv=iev@717 +std/core/int/(+): (x : int, y : int) -> <local<$96>,div,exn|$86> int 1literal: int
dec  = 1
hex8 = 0x01
bit8 = 0b00000001
      else
        resres: vector<$85>
?hdiv=iev@740.unsafe-assignck/vector/unsafe-assign: (v : vector<$85>, index : ssize_t, value : $85) -> <local<$96>,div,exn|$86> ()(pp: int
?hdiv=iev@758.ssize_tstd/core/int/ssize_t: (i : int) -> <local<$96>,div,exn|$86> ssize_t, temptemp: vector<$85>
?hdiv=iev@779.unsafe-idxck/vector/unsafe-idx: (v : vector<$85>, index : ssize_t) -> <local<$96>,div,exn|$86> $85((l1l1: int
?hdiv=iev@801 -std/core/int/(-): (x : int, y : int) -> <local<$96>,div,exn|$86> int ll: int).ssize_tstd/core/int/ssize_t: (i : int) -> <local<$96>,div,exn|$86> ssize_t))
        l1l1: local-var<$96,int> :=std/core/types/local-set: (v : local-var<$96,int>, assigned : int) -> <local<$96>,div,exn|$86> () l1l1: int
?hdiv=iev@832 +std/core/int/(+): (x : int, y : int) -> <local<$96>,div,exn|$86> int 1literal: int
dec  = 1
hex8 = 0x01
bit8 = 0b00000001
      pp: local-var<$96,int> :=std/core/types/local-set: (v : local-var<$96,int>, assigned : int) -> <local<$96>,div,exn|$86> () pp: int
?hdiv=iev@866 +std/core/int/(+): (x : int, y : int) -> <local<$96>,div,exn|$86> int 1literal: int
dec  = 1
hex8 = 0x01
bit8 = 0b00000001

    whilestd/core/while: (predicate : () -> <div,local<$96>,exn|$86> bool, action : () -> <div,local<$96>,exn|$86> ()) -> <div,local<$96>,exn|$86> () { l1l1: int
?hdiv=iev@892 <std/core/int/(<): (x : int, y : int) -> <local<$96>,div,exn|$86> bool mm: int }
      resres: vector<$85>
?hdiv=iev@949.unsafe-assignck/vector/unsafe-assign: (v : vector<$85>, index : ssize_t, value : $85) -> <local<$96>,div,exn|$86> ()(pp: int
?hdiv=iev@967.ssize_tstd/core/int/ssize_t: (i : int) -> <local<$96>,div,exn|$86> ssize_t, temptemp: vector<$85>
?hdiv=iev@988.unsafe-idxck/vector/unsafe-idx: (v : vector<$85>, index : ssize_t) -> <local<$96>,div,exn|$86> $85((l1l1: int
?hdiv=iev@1010 -std/core/int/(-): (x : int, y : int) -> <local<$96>,div,exn|$86> int ll: int).ssize_tstd/core/int/ssize_t: (i : int) -> <local<$96>,div,exn|$86> ssize_t))
      l1l1: local-var<$96,int> :=std/core/types/local-set: (v : local-var<$96,int>, assigned : int) -> <local<$96>,div,exn|$86> () l1l1: int
?hdiv=iev@1041 +std/core/int/(+): (x : int, y : int) -> <local<$96>,div,exn|$86> int 1literal: int
dec  = 1
hex8 = 0x01
bit8 = 0b00000001
      pp: local-var<$96,int> :=std/core/types/local-set: (v : local-var<$96,int>, assigned : int) -> <local<$96>,div,exn|$86> () pp: int
?hdiv=iev@1072 +std/core/int/(+): (x : int, y : int) -> <local<$96>,div,exn|$86> int 1literal: int
dec  = 1
hex8 = 0x01
bit8 = 0b00000001

  looploop: (l : int, r : int) -> <pure,local<$96>|$86> ()(0literal: int
dec  = 0
hex8 = 0x00
bit8 = 0b00000000, vv: vector<$85>.lengthstd/core/vector/length: (v : vector<$85>) -> <div,exn,local<$96>|$86> int)
  resres: vector<$85>
?hdiv=iev@1109

// Remove duplicates.
// Keep the first element for every consecutive sequence of duplicates.
// For example, `[1, 2, 2, 1].vector.uniq` evaluates to `[1, 2, 1]`.
pub fun uniqck/vector/uniq: forall<a,e> (v : vector<a>, @implicit/(==) : (a, a) -> <pure|e> bool) -> <pure|e> vector<a>(vv: vector<$3654>: vectorstd/core/types/vector: V -> V<aa: V>, (@implicit/==)?(==): ($3654, $3654) -> <pure|$3655> bool: (aa: V, aa: V) -> <purestd/core/pure: E|ee: E> boolstd/core/types/bool: V)result: -> <pure|4016> vector<4015>: <purestd/core/pure: E|ee: E> vectorstd/core/types/vector: V -> V<aa: V>
  fun uniq-nextuniq-next: (i : int, j : int) -> <pure|$3655> int(ii: int, jj: int)result: -> <div,exn|$3655> int
    if jj: int <std/core/int/(<): (x : int, y : int) -> <div,exn|$3655> bool vv: vector<$3654>.lengthstd/core/vector/length: (v : vector<$3654>) -> <div,exn|$3655> int &&std/core/types/(&&): (x : bool, y : bool) -> <div,exn|$3655> bool vv: vector<$3654>[jj: int] ==?(==): ($3654, $3654) -> <pure|$3655> bool vv: vector<$3654>[ii: int] then
      uniq-nextuniq-next: (i : int, j : int) -> <div,exn|$3655> int(ii: int, (jj: int +std/core/int/(+): (x : int, y : int) -> <div,exn|$3655> int 1literal: int
dec  = 1
hex8 = 0x01
bit8 = 0b00000001).pretend-decreasingstd/core/undiv/pretend-decreasing: (x : int) -> <div,exn|$3655> int)
    else
      jj: int
  fun uniq-loopuniq-loop: (i : int, acc : list<$3654>) -> <pure|$3655> list<$3654>(ii: int, accacc: list<$3654>)result: -> <div,exn|$3655> list<$3654>
    if ii: int ==std/core/int/(==): (x : int, y : int) -> <div,exn|$3655> bool vv: vector<$3654>.lengthstd/core/vector/length: (v : vector<$3654>) -> <div,exn|$3655> int then
      accacc: list<$3654>
    else
      uniq-loopuniq-loop: (i : int, acc : list<$3654>) -> <div,exn|$3655> list<$3654>(uniq-nextuniq-next: (i : int, j : int) -> <pure|$3655> int(ii: int, ii: int +std/core/int/(+): (x : int, y : int) -> <div,exn|$3655> int 1literal: int
dec  = 1
hex8 = 0x01
bit8 = 0b00000001), Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(vv: vector<$3654>[ii: int], accacc: list<$3654>))
  uniq-loopuniq-loop: (i : int, acc : list<$3654>) -> <pure|$3655> list<$3654>(0literal: int
dec  = 0
hex8 = 0x00
bit8 = 0b00000000, [std/core/types/Nil: forall<a> list<a>]std/core/types/Nil: forall<a> list<a>).reversestd/core/list/reverse: (xs : list<$3654>) -> <div,exn|$3655> list<$3654>.vectorstd/core/vector/list/vector: (xs : list<$3654>) -> <div,exn|$3655> vector<$3654>

// Return a vector whose `k`-th (0-based) element is the length of the longest
// common prefix of `v` and the suffix starting with `v[k]`.
pub fun z-algorithmck/vector/z-algorithm: forall<a> (v : vector<a>, @implicit/(==) : (a, a) -> bool) -> exn vector<int>(vv: vector<$1155>: vectorstd/core/types/vector: V -> V<aa: V>, (@implicit/==)?(==): ($1155, $1155) -> bool: (aa: V, aa: V) -> boolstd/core/types/bool: V)result: -> exn vector<int>: exnstd/core/exn/exn: (E, V) -> V vectorstd/core/types/vector: V -> V<intstd/core/types/int: V>
  val sizesize: int = vv: vector<$1155>.lengthstd/core/vector/length: (v : vector<$1155>) -> exn int
  if sizesize: int ==std/core/int/(==): (x : int, y : int) -> exn bool 0literal: int
dec  = 0
hex8 = 0x00
bit8 = 0b00000000 then returnreturn: vector<int> vectorstd/core/vector/vector: (n : int, default : int) -> exn vector<int>(0literal: int
dec  = 0
hex8 = 0x00
bit8 = 0b00000000, 0literal: int
dec  = 0
hex8 = 0x00
bit8 = 0b00000000)std/core/types/Unit: ()

  pretend-no-divstd/core/undiv/pretend-no-div: (action : () -> <div,exn> vector<int>) -> exn vector<int> {
    var resres: local-var<$1322,vector<int>> := vectorstd/core/vector/vector: (n : int, default : int) -> <div,exn,local<$1322>> vector<int>(sizesize: int, 0literal: int
dec  = 0
hex8 = 0x00
bit8 = 0b00000000)
    resres: local-var<$1322,vector<int>>[0literal: int
dec  = 0
hex8 = 0x00
bit8 = 0b00000000] := sizesize: int

    var ii: local-var<$1322,int> := 1literal: int
dec  = 1
hex8 = 0x01
bit8 = 0b00000001
    var jj: local-var<$1322,int> := 0literal: int
dec  = 0
hex8 = 0x00
bit8 = 0b00000000
    var kk: local-var<$1322,int> := 0literal: int
dec  = 0
hex8 = 0x00
bit8 = 0b00000000
    whilestd/core/while: (predicate : () -> <div,local<$1322>,exn> bool, action : () -> <div,local<$1322>,exn> ()) -> <div,local<$1322>,exn> () { ii: int
?hdiv=iev@1418 <std/core/int/(<): (x : int, y : int) -> <local<$1322>,div,exn> bool sizesize: int }
      whilestd/core/while: (predicate : () -> <div,exn,local<$1322>> bool, action : () -> <div,exn,local<$1322>> ()) -> <div,exn,local<$1322>> () { ii: int
?hdiv=iev@1478 +std/core/int/(+): (x : int, y : int) -> <local<$1322>,exn,div> int jj: int
?hdiv=iev@1497 <std/core/int/(<): (x : int, y : int) -> <local<$1322>,exn,div> bool sizesize: int &&std/core/types/(&&): (x : bool, y : bool) -> <exn,local<$1322>,div> bool vv: vector<$1155>[jj: int
?hdiv=iev@1592] ==?(==): ($1155, $1155) -> <exn,local<$1322>,div> bool vv: vector<$1155>[ii: int
?hdiv=iev@1684 +std/core/int/(+): (x : int, y : int) -> <local<$1322>,exn,div> int jj: int
?hdiv=iev@1698] }
        jj: local-var<$1322,int> :=std/core/types/local-set: (v : local-var<$1322,int>, assigned : int) -> <local<$1322>,div,exn> () jj: int
?hdiv=iev@1734 +std/core/int/(+): (x : int, y : int) -> <local<$1322>,div,exn> int 1literal: int
dec  = 1
hex8 = 0x01
bit8 = 0b00000001
      resres: local-var<$1322,vector<int>>[ii: int
?hdiv=iev@1765] := jj: int
?hdiv=iev@1779
      if jj: int
?hdiv=iev@1824 ==std/core/int/(==): (x : int, y : int) -> <local<$1322>,div,exn> bool 0literal: int
dec  = 0
hex8 = 0x00
bit8 = 0b00000000 then
        ii: local-var<$1322,int> :=std/core/types/local-set: (v : local-var<$1322,int>, assigned : int) -> <local<$1322>,div,exn> () ii: int
?hdiv=iev@1946 +std/core/int/(+): (x : int, y : int) -> <local<$1322>,div,exn> int 1literal: int
dec  = 1
hex8 = 0x01
bit8 = 0b00000001
        returnreturn: () (std/core/types/Unit: ())std/core/types/Unit: ()
      kk: local-var<$1322,int> :=std/core/types/local-set: (v : local-var<$1322,int>, assigned : int) -> <local<$1322>,div,exn> () 1literal: int
dec  = 1
hex8 = 0x01
bit8 = 0b00000001
      whilestd/core/while: (predicate : () -> <div,exn,local<$1322>> bool, action : () -> <div,exn,local<$1322>> ()) -> <div,exn,local<$1322>> () { ii: int
?hdiv=iev@1989 +std/core/int/(+): (x : int, y : int) -> <local<$1322>,exn,div> int kk: int
?hdiv=iev@2008 <std/core/int/(<): (x : int, y : int) -> <local<$1322>,exn,div> bool sizesize: int &&std/core/types/(&&): (x : bool, y : bool) -> <exn,local<$1322>,div> bool kk: int
?hdiv=iev@2056 +std/core/int/(+): (x : int, y : int) -> <exn,local<$1322>,div> int resres: vector<int>
?hdiv=iev@2086[kk: int
?hdiv=iev@2100] <std/core/int/(<): (x : int, y : int) -> <exn,local<$1322>,div> bool jj: int
?hdiv=iev@2144 }
        resres: local-var<$1322,vector<int>>[ii: int
?hdiv=iev@2186 +std/core/int/(+): (x : int, y : int) -> <local<$1322>,exn,div> int kk: int
?hdiv=iev@2200] := resres: vector<int>
?hdiv=iev@2225[kk: int
?hdiv=iev@2239]
        kk: local-var<$1322,int> :=std/core/types/local-set: (v : local-var<$1322,int>, assigned : int) -> <local<$1322>,exn,div> () kk: int
?hdiv=iev@2272 +std/core/int/(+): (x : int, y : int) -> <local<$1322>,exn,div> int 1literal: int
dec  = 1
hex8 = 0x01
bit8 = 0b00000001
      ii: local-var<$1322,int> :=std/core/types/local-set: (v : local-var<$1322,int>, assigned : int) -> <local<$1322>,div,exn> () ii: int
?hdiv=iev@2306 +std/core/int/(+): (x : int, y : int) -> <local<$1322>,div,exn> int kk: int
?hdiv=iev@2320
      jj: local-var<$1322,int> :=std/core/types/local-set: (v : local-var<$1322,int>, assigned : int) -> <local<$1322>,div,exn> () jj: int
?hdiv=iev@2350 -std/core/int/(-): (x : int, y : int) -> <local<$1322>,div,exn> int kk: int
?hdiv=iev@2364

    resres: vector<int>
?hdiv=iev@2384
  }

fun naive-searchck/vector/naive-search: forall<a> (v : vector<a>, sub : vector<a>, start : int, @implicit/(==) : (a, a) -> bool) -> exn maybe<int>(vv: vector<$2425>: vectorstd/core/types/vector: V -> V<aa: V>, subsub: vector<$2425>: vectorstd/core/types/vector: V -> V<aa: V>, startstart: int: intstd/core/types/int: V, (@implicit/==)?(==): ($2425, $2425) -> bool: (aa: V, aa: V) -> boolstd/core/types/bool: V)result: -> exn maybe<int>: exnstd/core/exn/exn: (E, V) -> V maybestd/core/types/maybe: V -> V<intstd/core/types/int: V>
  fun matchingmatching: (i : int, j : int) -> exn bool(ii: int: intstd/core/types/int: V, jj: int: intstd/core/types/int: V)result: -> exn bool: exnstd/core/exn/exn: (E, V) -> V boolstd/core/types/bool: V
    if jj: int ==std/core/int/(==): (x : int, y : int) -> exn bool subsub: vector<$2425>.lengthstd/core/vector/length: (v : vector<$2425>) -> exn int then returnreturn: bool Truestd/core/types/True: bool
    if !std/core/types/bool/(!): (b : bool) -> exn bool(vv: vector<$2425>[ii: int +std/core/int/(+): (x : int, y : int) -> exn int jj: int] ==?(==): ($2425, $2425) -> exn bool subsub: vector<$2425>[jj: int]) then returnreturn: bool Falsestd/core/types/False: bool
    matchingmatching: (i : int, j : int) -> exn bool(ii: int, (jj: int +std/core/int/(+): (x : int, y : int) -> exn int 1literal: int
dec  = 1
hex8 = 0x01
bit8 = 0b00000001).pretend-decreasingstd/core/undiv/pretend-decreasing: (x : int) -> exn int)
  fun looploop: (i : int) -> exn maybe<int>(ii: int: intstd/core/types/int: V)result: -> exn maybe<int>: exnstd/core/exn/exn: (E, V) -> V maybestd/core/types/maybe: V -> V<intstd/core/types/int: V>
    if ii: int +std/core/int/(+): (x : int, y : int) -> exn int subsub: vector<$2425>.lengthstd/core/vector/length: (v : vector<$2425>) -> exn int >std/core/int/(>): (x : int, y : int) -> exn bool vv: vector<$2425>.lengthstd/core/vector/length: (v : vector<$2425>) -> exn int then returnreturn: maybe<int> Nothingstd/core/types/Nothing: forall<a> maybe<a>
    if matchingmatching: (i : int, j : int) -> exn bool(ii: int, 0literal: int
dec  = 0
hex8 = 0x00
bit8 = 0b00000000) then returnreturn: maybe<int> Juststd/core/types/Just: forall<a> (value : a) -> maybe<a>(ii: int)std/core/types/Unit: ()
    looploop: (i : int) -> exn maybe<int>((ii: int +std/core/int/(+): (x : int, y : int) -> exn int 1literal: int
dec  = 1
hex8 = 0x01
bit8 = 0b00000001).pretend-decreasingstd/core/undiv/pretend-decreasing: (x : int) -> exn int)
  if startstart: int <std/core/int/(<): (x : int, y : int) -> exn bool 0literal: int
dec  = 0
hex8 = 0x00
bit8 = 0b00000000 then returnreturn: maybe<int> Nothingstd/core/types/Nothing: forall<a> maybe<a>
  looploop: (i : int) -> exn maybe<int>(startstart: int)

// Return the position of the first occurrence of `sub` in `v`.
// The first element is at position 0 (0-based).
// `start` specifies the starting position to search.
pub fun searchck/vector/search: forall<a> (v : vector<a>, sub : vector<a>, start : ? int, @implicit/(==) : (a, a) -> bool) -> <div,exn> maybe<int>(vv: vector<$2897>: vectorstd/core/types/vector: V -> V<aa: V>, subsub: vector<$2897>: vectorstd/core/types/vector: V -> V<aa: V>, startstart: ? int: intstd/core/types/int: V = 0literal: int
dec  = 0
hex8 = 0x00
bit8 = 0b00000000, (@implicit/==)?(==): ($2897, $2897) -> bool: (aa: V, aa: V) -> boolstd/core/types/bool: V)result: -> <div,exn> maybe<int>: <std/core/types/total: Edivstd/core/types/div: X,exnstd/core/exn/exn: (E, V) -> V> maybestd/core/types/maybe: V -> V<intstd/core/types/int: V>
  // this line improves performance?
  if subsub: vector<$2897>.lengthstd/core/vector/length: (v : vector<$2897>) -> <exn,div> int <std/core/int/(<): (x : int, y : int) -> <exn,div> bool 16literal: int
dec  = 16
hex8 = 0x10
bit8 = 0b00010000 then returnreturn: maybe<int> naive-searchck/vector/naive-search: (v : vector<$2897>, sub : vector<$2897>, start : int, @implicit/(==) : ($2897, $2897) -> bool) -> <exn,div> maybe<int>
?(==)=?(==)(vv: vector<$2897>, subsub: vector<$2897>, startstart: int)std/core/types/Unit: ()

  if startstart: int <std/core/int/(<): (x : int, y : int) -> <exn,div> bool 0literal: int
dec  = 0
hex8 = 0x00
bit8 = 0b00000000 ||std/core/types/(||): (x : bool, y : bool) -> <exn,div> bool startstart: int +std/core/int/(+): (x : int, y : int) -> <exn,div> int subsub: vector<$2897>.lengthstd/core/vector/length: (v : vector<$2897>) -> <exn,div> int >std/core/int/(>): (x : int, y : int) -> <exn,div> bool vv: vector<$2897>.lengthstd/core/vector/length: (v : vector<$2897>) -> <exn,div> int then returnreturn: maybe<int> Nothingstd/core/types/Nothing: forall<a> maybe<a>
  // w = sub + v[start:]
  val ww: vector<$2897> = vector-initstd/core/vector/vector-init: (n : int, f : (int) -> <exn,div> $2897) -> <exn,div> vector<$2897>(
    subsub: vector<$2897>.lengthstd/core/vector/length: (v : vector<$2897>) -> <exn,div> int +std/core/int/(+): (x : int, y : int) -> <exn,div> int vv: vector<$2897>.lengthstd/core/vector/length: (v : vector<$2897>) -> <exn,div> int -std/core/int/(-): (x : int, y : int) -> <exn,div> int startstart: int,
    fnfn: (i : int) -> <exn,div> $2897(ii: int) { if ii: int <std/core/int/(<): (x : int, y : int) -> <exn,div> bool subsub: vector<$2897>.lengthstd/core/vector/length: (v : vector<$2897>) -> <exn,div> int then subsub: vector<$2897>[ii: int] else vv: vector<$2897>[ii: int -std/core/int/(-): (x : int, y : int) -> <exn,div> int subsub: vector<$2897>.lengthstd/core/vector/length: (v : vector<$2897>) -> <exn,div> int +std/core/int/(+): (x : int, y : int) -> <exn,div> int startstart: int] }
  )
  val ll: vector<int> = z-algorithmck/vector/z-algorithm: (v : vector<$2897>, @implicit/(==) : ($2897, $2897) -> bool) -> <exn,div> vector<int>
?(==)=?(==)(ww: vector<$2897>)
  fun looploop: (i : int) -> exn maybe<int>(ii: int: intstd/core/types/int: V)result: -> exn maybe<int>: exnstd/core/exn/exn: (E, V) -> V maybestd/core/types/maybe: V -> V<intstd/core/types/int: V>
    if ii: int +std/core/int/(+): (x : int, y : int) -> exn int subsub: vector<$2897>.lengthstd/core/vector/length: (v : vector<$2897>) -> exn int >std/core/int/(>): (x : int, y : int) -> exn bool vv: vector<$2897>.lengthstd/core/vector/length: (v : vector<$2897>) -> exn int then returnreturn: maybe<int> Nothingstd/core/types/Nothing: forall<a> maybe<a>
    val foundfound: bool = ll: vector<int>[subsub: vector<$2897>.lengthstd/core/vector/length: (v : vector<$2897>) -> exn int +std/core/int/(+): (x : int, y : int) -> exn int ii: int -std/core/int/(-): (x : int, y : int) -> exn int startstart: int] >=std/core/int/(>=): (x : int, y : int) -> exn bool subsub: vector<$2897>.lengthstd/core/vector/length: (v : vector<$2897>) -> exn int
    if foundfound: bool then returnreturn: maybe<int> Juststd/core/types/Just: forall<a> (value : a) -> maybe<a>(ii: int)std/core/types/Unit: ()
    looploop: (i : int) -> exn maybe<int>((ii: int +std/core/int/(+): (x : int, y : int) -> exn int 1literal: int
dec  = 1
hex8 = 0x01
bit8 = 0b00000001).pretend-decreasingstd/core/undiv/pretend-decreasing: (x : int) -> exn int)
  looploop: (i : int) -> <exn,div> maybe<int>(startstart: int)

// Return the given vector, but with the elements reversed.
pub fun reverseck/vector/reverse: forall<a> (v : vector<a>) -> exn vector<a>(vv: vector<$3589>: vectorstd/core/types/vector: V -> V<aa: V>)result: -> exn vector<3649>: exnstd/core/exn/exn: (E, V) -> V vectorstd/core/types/vector: V -> V<aa: V>
  vector-initstd/core/vector/vector-init: (n : int, f : (int) -> exn $3589) -> exn vector<$3589>(vv: vector<$3589>.lengthstd/core/vector/length: (v : vector<$3589>) -> exn int, fnfn: (i : int) -> exn $3589(ii: int) vv: vector<$3589>[vv: vector<$3589>.lengthstd/core/vector/length: (v : vector<$3589>) -> exn int -std/core/int/(-): (x : int, y : int) -> exn int 1literal: int
dec  = 1
hex8 = 0x01
bit8 = 0b00000001 -std/core/int/(-): (x : int, y : int) -> exn int ii: int])