sig
  module I :
    sig
      type t = int
      val pp :
        Format.formatter -> SrkUtil.Int.I.t -> Ppx_deriving_runtime.unit
      val show : SrkUtil.Int.I.t -> Ppx_deriving_runtime.string
      val compare :
        SrkUtil.Int.I.t -> SrkUtil.Int.I.t -> Ppx_deriving_runtime.int
      val hash : 'a -> int
      val equal : 'a -> 'a -> bool
    end
  type t = int
  val pp : Format.formatter -> t -> Ppx_deriving_runtime.unit
  val show : t -> Ppx_deriving_runtime.string
  val compare : t -> t -> Ppx_deriving_runtime.int
  val hash : 'a -> int
  val equal : 'a -> 'a -> bool
  module Set :
    sig
      type elt = I.t
      type t = BatSet.Make(I).t
      val empty : t
      val is_empty : t -> bool
      val singleton : elt -> t
      val mem : elt -> t -> bool
      val find : elt -> t -> elt
      val add : elt -> t -> t
      val remove : elt -> t -> t
      val update : elt -> elt -> t -> t
      val union : t -> t -> t
      val inter : t -> t -> t
      val diff : t -> t -> t
      val sym_diff : t -> t -> t
      val compare : t -> t -> int
      val equal : t -> t -> bool
      val subset : t -> t -> bool
      val disjoint : t -> t -> bool
      val compare_subset : t -> t -> int
      val iter : (elt -> unit) -> t -> unit
      val at_rank_exn : int -> t -> elt
      val map : (elt -> elt) -> t -> t
      val filter : (elt -> bool) -> t -> t
      val filter_map : (elt -> elt option) -> t -> t
      val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
      val for_all : (elt -> bool) -> t -> bool
      val exists : (elt -> bool) -> t -> bool
      val partition : (elt -> bool) -> t -> t * t
      val split : elt -> t -> t * bool * t
      val split_opt : elt -> t -> t * elt option * t
      val split_lt : elt -> t -> t * t
      val split_le : elt -> t -> t * t
      val cardinal : t -> int
      val elements : t -> elt list
      val to_list : t -> elt list
      val to_array : t -> elt array
      val min_elt : t -> elt
      val pop_min : t -> elt * t
      val pop_max : t -> elt * t
      val max_elt : t -> elt
      val choose : t -> elt
      val pop : t -> elt * t
      val enum : t -> elt BatEnum.t
      val backwards : t -> elt BatEnum.t
      val of_enum : elt BatEnum.t -> t
      val of_list : elt list -> t
      val of_array : elt array -> t
      val print :
        ?first:string ->
        ?last:string ->
        ?sep:string ->
        ('a BatInnerIO.output -> elt -> unit) ->
        'a BatInnerIO.output -> t -> unit
      module Infix :
        sig
          val ( <-- ) : t -> elt -> t
          val ( <. ) : t -> t -> bool
          val ( >. ) : t -> t -> bool
          val ( <=. ) : t -> t -> bool
          val ( >=. ) : t -> t -> bool
          val ( -. ) : t -> t -> t
          val ( &&. ) : t -> t -> t
          val ( ||. ) : t -> t -> t
        end
      module Exceptionless :
        sig
          val min_elt : t -> elt option
          val max_elt : t -> elt option
          val choose : t -> elt option
          val find : elt -> t -> elt option
        end
      module Labels :
        sig
          val iter : f:(elt -> unit) -> t -> unit
          val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a
          val for_all : f:(elt -> bool) -> t -> bool
          val exists : f:(elt -> bool) -> t -> bool
          val map : f:(elt -> elt) -> t -> t
          val filter : f:(elt -> bool) -> t -> t
          val filter_map : f:(elt -> elt option) -> t -> t
          val partition : f:(elt -> bool) -> t -> t * t
        end
      val pp : Format.formatter -> t -> unit
    end
  module Map :
    sig
      type key = I.t
      type 'a t = 'a BatMap.Make(I).t
      val empty : 'a t
      val is_empty : 'a t -> bool
      val cardinal : 'a t -> int
      val add : key -> 'a -> 'a t -> 'a t
      val update : key -> key -> 'a -> 'a t -> 'a t
      val find : key -> 'a t -> 'a
      val remove : key -> 'a t -> 'a t
      val modify : key -> ('a -> 'a) -> 'a t -> 'a t
      val modify_def : 'a -> key -> ('a -> 'a) -> 'a t -> 'a t
      val modify_opt : key -> ('a option -> 'a option) -> 'a t -> 'a t
      val extract : key -> 'a t -> 'a * 'a t
      val pop : 'a t -> (key * 'a) * 'a t
      val mem : key -> 'a t -> bool
      val iter : (key -> 'a -> unit) -> 'a t -> unit
      val map : ('a -> 'b) -> 'a t -> 'b t
      val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
      val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
      val filterv : ('a -> bool) -> 'a t -> 'a t
      val filter : (key -> 'a -> bool) -> 'a t -> 'a t
      val filter_map : (key -> 'a -> 'b option) -> 'a t -> 'b t
      val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
      val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
      val keys : 'a t -> key BatEnum.t
      val values : 'a t -> 'a BatEnum.t
      val min_binding : 'a t -> key * 'a
      val pop_min_binding : 'a t -> (key * 'a) * 'a t
      val max_binding : 'a t -> key * 'a
      val pop_max_binding : 'a t -> (key * 'a) * 'a t
      val choose : 'a t -> key * 'a
      val split : key -> 'a t -> 'a t * 'a option * 'a t
      val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
      val singleton : key -> 'a -> 'a t
      val bindings : 'a t -> (key * 'a) list
      val enum : 'a t -> (key * 'a) BatEnum.t
      val backwards : 'a t -> (key * 'a) BatEnum.t
      val of_enum : (key * 'a) BatEnum.t -> 'a t
      val for_all : (key -> 'a -> bool) -> 'a t -> bool
      val exists : (key -> 'a -> bool) -> 'a t -> bool
      val merge :
        (key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
      val print :
        ?first:string ->
        ?last:string ->
        ?sep:string ->
        ?kvsep:string ->
        ('a BatInnerIO.output -> key -> unit) ->
        ('a BatInnerIO.output -> 'c -> unit) ->
        'a BatInnerIO.output -> 'c t -> unit
      module Exceptionless : sig val find : key -> 'a t -> 'a option end
      module Infix :
        sig
          val ( --> ) : 'a t -> key -> 'a
          val ( <-- ) : 'a t -> key * 'a -> 'a t
        end
      module Labels :
        sig
          val add : key:key -> data:'a -> 'a t -> 'a t
          val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit
          val map : f:('a -> 'b) -> 'a t -> 'b t
          val mapi : f:(key:key -> data:'a -> 'b) -> 'a t -> 'b t
          val filterv : f:('a -> bool) -> 'a t -> 'a t
          val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t
          val fold :
            f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b
          val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int
          val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool
        end
    end
end