sig
  type 'a t = 'a array
  type 'a enumerable = 'a t
  type 'a mappable = 'a t
  external length : 'a array -> int = "%array_length"
  external get : 'a array -> int -> 'a = "%array_safe_get"
  external set : 'a array -> int -> 'a -> unit = "%array_safe_set"
  external make : int -> 'a -> 'a array = "caml_make_vect"
  external create_float : int -> float array = "caml_make_float_vect"
  val make_float : int -> float array
  val of_seq : 'a Seq.t -> 'a array
  val to_seq : 'a array -> 'a Seq.t
  val to_seqi : 'a array -> (int * 'a) Seq.t
  external create : int -> 'a -> 'a array = "caml_make_vect"
  val init : int -> (int -> 'a) -> 'a array
  val make_matrix : int -> int -> 'a -> 'a array array
  val create_matrix : int -> int -> 'a -> 'a array array
  val append : 'a array -> 'a array -> 'a array
  val concat : 'a array list -> 'a array
  val sub : 'a array -> int -> int -> 'a array
  val copy : 'a array -> 'a array
  val fill : 'a array -> int -> int -> 'a -> unit
  val blit : 'a array -> int -> 'a array -> int -> int -> unit
  val to_list : 'a array -> 'a list
  val split : ('a * 'b) array -> 'a array * 'b array
  val combine : 'a array -> 'b array -> ('a * 'b) array
  val of_list : 'a list -> 'a array
  val max : 'a array -> 'a
  val min : 'a array -> 'a
  val min_max : 'a array -> 'a * 'a
  val sum : int array -> int
  val fsum : float array -> float
  val kahan_sum : float array -> float
  val avg : int array -> float
  val favg : float array -> float
  val left : 'a array -> int -> 'a array
  val right : 'a array -> int -> 'a array
  val head : 'a array -> int -> 'a array
  val tail : 'a array -> int -> 'a array
  val iter : ('a -> unit) -> 'a array -> unit
  val map : ('a -> 'b) -> 'a array -> 'b array
  val iteri : (int -> 'a -> unit) -> 'a array -> unit
  val mapi : (int -> 'a -> 'b) -> 'a array -> 'b array
  val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b array -> 'a
  val fold_left_map :
    ('a -> 'b -> 'a * 'c) -> 'a -> 'b array -> 'a * 'c array
  val fold_while :
    ('acc -> 'a -> bool) ->
    ('acc -> 'a -> 'acc) -> 'acc -> 'a array -> 'acc * int
  val fold : ('a -> 'b -> 'a) -> 'a -> 'b array -> 'a
  val fold_right : ('b -> 'a -> 'a) -> 'b array -> 'a -> 'a
  val modify : ('a -> 'a) -> 'a array -> unit
  val modifyi : (int -> 'a -> 'a) -> 'a array -> unit
  val fold_lefti : ('a -> int -> 'b -> 'a) -> 'a -> 'b array -> 'a
  val fold_righti : (int -> 'b -> 'a -> 'a) -> 'b array -> 'a -> 'a
  val reduce : ('a -> 'a -> 'a) -> 'a array -> 'a
  val singleton : 'a -> 'a array
  val sort : ('a -> 'a -> int) -> 'a array -> unit
  val stable_sort : ('a -> 'a -> int) -> 'a array -> unit
  val fast_sort : ('a -> 'a -> int) -> 'a array -> unit
  val decorate_stable_sort : ('a -> 'b) -> 'a array -> 'a array
  val decorate_fast_sort : ('a -> 'b) -> 'a array -> 'a array
  val bsearch :
    'a BatOrd.ord ->
    'a array ->
    'a ->
    [ `All_bigger | `All_lower | `At of int | `Empty | `Just_after of int ]
  val pivot_split : 'a BatOrd.ord -> 'a array -> 'a -> int * int
  val iter2 : ('a -> 'b -> unit) -> 'a array -> 'b array -> unit
  val iter2i : (int -> 'a -> 'b -> unit) -> 'a array -> 'b array -> unit
  val for_all2 : ('a -> 'b -> bool) -> 'a array -> 'b array -> bool
  val exists2 : ('a -> 'b -> bool) -> 'a array -> 'b array -> bool
  val map2 : ('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array
  val cartesian_product : 'a array -> 'b array -> ('a * 'b) array
  val for_all : ('a -> bool) -> 'a array -> bool
  val exists : ('a -> bool) -> 'a array -> bool
  val find_opt : ('a -> bool) -> 'a array -> 'a option
  val find_map : ('a -> 'b option) -> 'a array -> 'b option
  val mem : 'a -> 'a array -> bool
  val memq : 'a -> 'a array -> bool
  val filter : ('a -> bool) -> 'a array -> 'a array
  val filteri : (int -> 'a -> bool) -> 'a array -> 'a array
  val filter_map : ('a -> 'b option) -> 'a array -> 'b array
  val count_matching : ('a -> bool) -> 'a array -> int
  val find_all : ('a -> bool) -> 'a array -> 'a array
  val partition : ('a -> bool) -> 'a array -> 'a array * 'a array
  val rev : 'a array -> 'a array
  val rev_in_place : 'a array -> unit
  val enum : 'a array -> 'a BatEnum.t
  val of_enum : 'a BatEnum.t -> 'a array
  val backwards : 'a array -> 'a BatEnum.t
  val of_backwards : 'a BatEnum.t -> 'a array
  val range : 'a array -> int BatEnum.t
  val insert : 'a array -> 'a -> int -> 'a array
  val remove_at : int -> 'a array -> 'a array
  val print :
    ?first:string ->
    ?last:string ->
    ?sep:string -> ('a, 'b) BatIO.printer -> ('a t, 'b) BatIO.printer
  val compare : 'a BatOrd.comp -> 'a array BatOrd.comp
  val ord : 'a BatOrd.ord -> 'a array BatOrd.ord
  val shuffle : ?state:Random.State.t -> 'a array -> unit
  val equal : 'a BatOrd.eq -> 'a array BatOrd.eq
  module Exceptionless :
    sig
      val find : ('a -> bool) -> 'a t -> 'a option
      val findi : ('a -> bool) -> 'a t -> int option
    end
  module Incubator :
    sig
      module Eq :
        functor (T : BatOrd.Eq) ->
          sig type t = T.t array val eq : T.t array BatOrd.eq end
      module Ord :
        functor (T : BatOrd.Ord) ->
          sig type t = T.t array val ord : T.t array BatOrd.ord end
    end
  val is_sorted_by : ('a -> 'b) -> 'a array -> bool
  external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get"
  external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set"
  module Floatarray :
    sig
      external create : int -> floatarray = "caml_floatarray_create"
      external length : floatarray -> int = "%floatarray_length"
      external get : floatarray -> int -> float = "%floatarray_safe_get"
      external set : floatarray -> int -> float -> unit
        = "%floatarray_safe_set"
      external unsafe_get : floatarray -> int -> float
        = "%floatarray_unsafe_get"
      external unsafe_set : floatarray -> int -> float -> unit
        = "%floatarray_unsafe_set"
    end
  val find : ('a -> bool) -> 'a BatArray.t -> 'a option
  val findi : ('a -> bool) -> 'a BatArray.t -> int option
  module Labels :
    sig
      val init : int -> f:(int -> 'a) -> 'a array
      val create : int -> init:'a -> 'a array
      val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array
      val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array
      val sub : 'a array -> pos:int -> len:int -> 'a array
      val fill : 'a array -> pos:int -> len:int -> 'a -> unit
      val blit :
        src:'a array ->
        src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit
      val iter : f:('a -> unit) -> 'a array -> unit
      val iteri : f:(int -> 'a -> unit) -> 'a array -> unit
      val modify : f:('a -> 'a) -> 'a array -> unit
      val modifyi : f:(int -> 'a -> 'a) -> 'a array -> unit
      val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a
      val fold : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a
      val fold_right : f:('b -> 'a -> 'a) -> 'b array -> init:'a -> 'a
      val fold_while :
        p:('acc -> 'a -> bool) ->
        f:('acc -> 'a -> 'acc) -> init:'acc -> 'a array -> 'acc * int
      val sort : cmp:('a -> 'a -> int) -> 'a array -> unit
      val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit
      val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit
      val iter2 :
        f:('a -> 'b -> unit) -> 'a BatArray.t -> 'b BatArray.t -> unit
      val exists : f:('a -> bool) -> 'a BatArray.t -> bool
      val for_all : f:('a -> bool) -> 'a BatArray.t -> bool
      val iter2i :
        f:(int -> 'a -> 'b -> unit) -> 'a BatArray.t -> 'b BatArray.t -> unit
      val find_opt : f:('a -> bool) -> 'a BatArray.t -> 'a option
      val find_map : f:('a -> 'b option) -> 'a array -> 'b option
      val map : f:('a -> 'b) -> 'a BatArray.t -> 'b BatArray.t
      val mapi : f:(int -> 'a -> 'b) -> 'a BatArray.t -> 'b BatArray.t
      val filter : f:('a -> bool) -> 'a BatArray.t -> 'a BatArray.t
      val filter_map : f:('a -> 'b option) -> 'a BatArray.t -> 'b BatArray.t
      val count_matching : f:('a -> bool) -> 'a BatArray.t -> int
      module LExceptionless = BatArray.Labels.LExceptionless
      val find : f:('a -> bool) -> 'a BatArray.t -> 'a option
      val findi : f:('a -> bool) -> 'a BatArray.t -> int option
    end
  module Cap :
    sig
      type ('a, 'b) t = ('a, 'b) BatArray.Cap.t
        constraint 'b = [< `Read | `Write ]
      external length : ('a, [< `Read | `Write ]) t -> int = "%array_length"
      external get : ('a, [< `Read | `Write > `Read ]) t -> int -> 'a
        = "%array_safe_get"
      external set :
        ('a, [< `Read | `Write > `Write ]) t -> int -> 'a -> unit
        = "%array_safe_set"
      external make : int -> 'a -> ('a, [< `Read | `Write ]) t
        = "caml_make_vect"
      external create : int -> 'a -> ('a, [< `Read | `Write ]) t
        = "caml_make_vect"
      external make_float : int -> (float, [< `Read | `Write ]) t
        = "caml_make_float_vect"
      external of_array : 'a array -> ('a, [< `Read | `Write ]) t
        = "%identity"
      external to_array : ('a, [ `Read | `Write ]) t -> 'a array
        = "%identity"
      external read_only :
        ('a, [< `Read | `Write > `Read ]) t -> ('a, [ `Read ]) t
        = "%identity"
      external write_only :
        ('a, [< `Read | `Write > `Write ]) t -> ('a, [ `Write ]) t
        = "%identity"
      val init : int -> (int -> 'a) -> ('a, [< `Read | `Write ]) t
      val make_matrix :
        int ->
        int -> 'a -> (('a, [< `Read | `Write ]) t, [< `Read | `Write ]) t
      val create_matrix :
        int ->
        int -> 'a -> (('a, [< `Read | `Write ]) t, [< `Read | `Write ]) t
      val iter : ('a -> unit) -> ('a, [< `Read | `Write > `Read ]) t -> unit
      val map :
        ('a -> 'b) ->
        ('a, [< `Read | `Write > `Read ]) t -> ('b, [< `Read | `Write ]) t
      val iteri :
        (int -> 'a -> unit) -> ('a, [< `Read | `Write > `Read ]) t -> unit
      val mapi :
        (int -> 'a -> 'b) ->
        ('a, [< `Read | `Write > `Read ]) t -> ('b, [< `Read | `Write ]) t
      val modify : ('a -> 'a) -> ('a, [ `Read | `Write ]) t -> unit
      val modifyi : (int -> 'a -> 'a) -> ('a, [ `Read | `Write ]) t -> unit
      val fold_left :
        ('a -> 'b -> 'a) -> 'a -> ('b, [< `Read | `Write > `Read ]) t -> 'a
      val fold :
        ('a -> 'b -> 'a) -> 'a -> ('b, [< `Read | `Write > `Read ]) t -> 'a
      val fold_right :
        ('b -> 'a -> 'a) -> ('b, [< `Read | `Write > `Read ]) t -> 'a -> 'a
      val fold_while :
        ('acc -> 'a -> bool) ->
        ('acc -> 'a -> 'acc) ->
        'acc -> ('a, [< `Read | `Write > `Read ]) t -> 'acc * int
      val iter2 :
        ('a -> 'b -> unit) ->
        ('a, [< `Read | `Write > `Read ]) t ->
        ('b, [< `Read | `Write > `Read ]) t -> unit
      val iter2i :
        (int -> 'a -> 'b -> unit) ->
        ('a, [< `Read | `Write > `Read ]) t ->
        ('b, [< `Read | `Write > `Read ]) t -> unit
      val for_all :
        ('a -> bool) -> ('a, [< `Read | `Write > `Read ]) t -> bool
      val exists :
        ('a -> bool) -> ('a, [< `Read | `Write > `Read ]) t -> bool
      val find_opt :
        ('a -> bool) -> ('a, [< `Read | `Write > `Read ]) t -> 'a option
      val find_map :
        ('a -> 'b option) -> ('a, [< `Read | `Write > `Read ]) t -> 'b option
      val mem : 'a -> ('a, [< `Read | `Write > `Read ]) t -> bool
      val memq : 'a -> ('a, [< `Read | `Write > `Read ]) t -> bool
      val filter :
        ('a -> bool) ->
        ('a, [< `Read | `Write > `Read ]) t -> ('a, [< `Read | `Write ]) t
      val filter_map :
        ('a -> 'b option) ->
        ('a, [< `Read | `Write > `Read ]) t -> ('b, [< `Read | `Write ]) t
      val count_matching :
        ('a -> bool) -> ('a, [< `Read | `Write > `Read ]) t -> int
      val find_all :
        ('a -> bool) ->
        ('a, [< `Read | `Write > `Read ]) t -> ('a, [< `Read | `Write ]) t
      val partition :
        ('a -> bool) ->
        ('a, [< `Read | `Write > `Read ]) t ->
        ('a, [< `Read | `Write ]) t * ('a, [< `Read | `Write ]) t
      val rev :
        ('a, [< `Read | `Write > `Read ]) t -> ('a, [< `Read | `Write ]) t
      val rev_in_place : ('a, [ `Read | `Write ]) t -> unit
      val append :
        ('a, [< `Read | `Write > `Read ]) t ->
        ('a, [< `Read | `Write > `Read ]) t -> ('a, [< `Read | `Write ]) t
      val concat :
        ('a, [< `Read | `Write > `Read ]) t list ->
        ('a, [< `Read | `Write ]) t
      val sub :
        ('a, [< `Read | `Write > `Read ]) t ->
        int -> int -> ('a, [< `Read | `Write ]) t
      val copy : ('a, [< `Read | `Write > `Read ]) t -> 'a array
      val fill :
        ('a, [< `Read | `Write > `Write ]) t -> int -> int -> 'a -> unit
      val blit :
        ('a, [< `Read | `Write > `Read ]) t ->
        int -> ('a, [< `Read | `Write > `Write ]) t -> int -> int -> unit
      val enum : ('a, [< `Read | `Write > `Read ]) t -> 'a BatEnum.t
      val of_enum : 'a BatEnum.t -> ('a, [< `Read | `Write ]) t
      val backwards : ('a, [< `Read | `Write > `Read ]) t -> 'a BatEnum.t
      val of_backwards : 'a BatEnum.t -> ('a, [< `Read | `Write ]) t
      val to_list : ('a, [< `Read | `Write > `Read ]) t -> 'a list
      val split :
        ('a * 'b, [< `Read | `Write > `Read ]) t ->
        ('a, [< `Read | `Write ]) t * ('b, [< `Read | `Write ]) t
      val combine :
        ('a, [< `Read | `Write > `Read ]) t ->
        ('b, [< `Read | `Write > `Read ]) t ->
        ('a * 'b, [< `Read | `Write > `Read ]) t
      val pivot_split :
        'a BatOrd.ord ->
        ('a, [< `Read | `Write > `Read ]) t -> 'a -> int * int
      val of_list : 'a list -> ('a, [< `Read | `Write ]) t
      val sort : ('a -> 'a -> int) -> ('a, [ `Read | `Write ]) t -> unit
      val stable_sort :
        ('a -> 'a -> int) -> ('a, [ `Read | `Write ]) t -> unit
      val fast_sort : ('a -> 'a -> int) -> ('a, [ `Read | `Write ]) t -> unit
      val print :
        ?first:string ->
        ?last:string ->
        ?sep:string ->
        ('a BatIO.output -> 'b -> unit) ->
        'a BatIO.output -> ('b, [< `Read | `Write > `Read ]) t -> unit
      val compare :
        'a BatOrd.comp -> ('a, [< `Read | `Write > `Read ]) t BatOrd.comp
      val ord :
        'a BatOrd.ord -> ('a, [< `Read | `Write > `Read ]) t BatOrd.ord
      val equal :
        'a BatOrd.eq -> ('a, [< `Read | `Write > `Read ]) t BatOrd.eq
      module Exceptionless = BatArray.Cap.Exceptionless
      module Labels = BatArray.Cap.Labels
      external unsafe_get : ('a, [< `Read | `Write > `Read ]) t -> int -> 'a
        = "%array_unsafe_get"
      external unsafe_set :
        ('a, [< `Read | `Write > `Write ]) t -> int -> 'a -> unit
        = "%array_unsafe_set"
      val find :
        ('a -> bool) ->
        ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t -> 'a option
      val findi :
        ('a -> bool) ->
        ('a, [< `Read | `Write > `Read ]) BatArray.Cap.t -> int option
    end
end