sig   module Tuple2 :     sig       type ('a, 'b) t = 'a * 'b       val make : '-> '-> 'a * 'b       external first : 'a * '-> 'a = "%field0"       external second : 'a * '-> 'b = "%field1"       val swap : 'a * '-> 'b * 'a       val map : ('-> 'c) -> ('-> 'd) -> 'a * '-> 'c * 'd       val mapn : ('-> 'b) -> 'a * '-> 'b * 'b       val map1 : ('-> 'c) -> 'a * '-> 'c * 'b       val map2 : ('-> 'c) -> 'a * '-> 'a * 'c       val curry : ('a * '-> 'c) -> '-> '-> 'c       val uncurry : ('-> '-> 'c) -> 'a * '-> 'c       val print :         ?first:string ->         ?sep:string ->         ?last:string ->         ('BatIO.output -> '-> unit) ->         ('BatIO.output -> '-> unit) -> 'BatIO.output -> 'a * '-> unit       val printn :         ?first:string ->         ?sep:string ->         ?last:string ->         ('BatIO.output -> '-> unit) -> 'BatIO.output -> 'a * '-> unit       val compare :         ?cmp1:('-> '-> int) ->         ?cmp2:('-> '-> int) -> 'a * '-> 'a * '-> int       type 'a enumerable = 'a * 'a       val enum : 'a enumerable -> 'BatEnum.t       val of_enum : 'BatEnum.t -> 'a enumerable       val eq : 'BatOrd.eq -> 'BatOrd.eq -> ('a * 'b) BatOrd.eq       val ord : 'BatOrd.ord -> 'BatOrd.ord -> ('a * 'b) BatOrd.ord       val comp : 'BatOrd.comp -> 'BatOrd.comp -> ('a * 'b) BatOrd.comp       module Eq :         functor (T1 : BatOrd.Eq) (T2 : BatOrd.Eq->           sig type t = T1.t * T2.t val eq : t BatOrd.eq end       module Ord :         functor (T1 : BatOrd.Ord) (T2 : BatOrd.Ord->           sig type t = T1.t * T2.t val ord : t BatOrd.ord end       module Comp :         functor (T1 : BatOrd.Comp) (T2 : BatOrd.Comp->           sig type t = T1.t * T2.t val compare : t BatOrd.comp end     end   module Tuple3 :     sig       type ('a, 'b, 'c) t = 'a * 'b * 'c       val make : '-> '-> '-> 'a * 'b * 'c       val first : 'a * 'b * '-> 'a       val second : 'a * 'b * '-> 'b       val third : 'a * 'b * '-> 'c       val get12 : 'a * 'b * '-> 'a * 'b       val get13 : 'a * 'b * '-> 'a * 'c       val get23 : 'a * 'b * '-> 'b * 'c       val map :         ('-> 'd) ->         ('-> 'e) -> ('-> 'f) -> 'a * 'b * '-> 'd * 'e * 'f       val mapn : ('-> 'b) -> 'a * 'a * '-> 'b * 'b * 'b       val map1 : ('-> 'd) -> 'a * 'b * '-> 'd * 'b * 'c       val map2 : ('-> 'd) -> 'a * 'b * '-> 'a * 'd * 'c       val map3 : ('-> 'd) -> 'a * 'b * '-> 'a * 'b * 'd       val curry : ('a * 'b * '-> 'd) -> '-> '-> '-> 'd       val uncurry : ('-> '-> '-> 'd) -> 'a * 'b * '-> 'd       val print :         ?first:string ->         ?sep:string ->         ?last:string ->         ('BatIO.output -> '-> unit) ->         ('BatIO.output -> '-> unit) ->         ('BatIO.output -> '-> unit) ->         'BatIO.output -> 'a * 'b * '-> unit       val printn :         ?first:string ->         ?sep:string ->         ?last:string ->         ('BatIO.output -> '-> unit) ->         'BatIO.output -> 'a * 'a * '-> unit       val compare :         ?cmp1:('-> '-> int) ->         ?cmp2:('-> '-> int) ->         ?cmp3:('-> '-> int) -> 'a * 'b * '-> 'a * 'b * '-> int       type 'a enumerable = 'a * 'a * 'a       val enum : 'a enumerable -> 'BatEnum.t       val of_enum : 'BatEnum.t -> 'a enumerable       val eq :         'BatOrd.eq ->         'BatOrd.eq -> 'BatOrd.eq -> ('a * 'b * 'c) BatOrd.eq       val ord :         'BatOrd.ord ->         'BatOrd.ord -> 'BatOrd.ord -> ('a * 'b * 'c) BatOrd.ord       val comp :         'BatOrd.comp ->         'BatOrd.comp -> 'BatOrd.comp -> ('a * 'b * 'c) BatOrd.comp       module Eq :         functor (T1 : BatOrd.Eq) (T2 : BatOrd.Eq) (T3 : BatOrd.Eq->           sig type t = T1.t * T2.t * T3.t val eq : t BatOrd.eq end       module Ord :         functor (T1 : BatOrd.Ord) (T2 : BatOrd.Ord) (T3 : BatOrd.Ord->           sig type t = T1.t * T2.t * T3.t val ord : t BatOrd.ord end       module Comp :         functor (T1 : BatOrd.Comp) (T2 : BatOrd.Comp) (T3 : BatOrd.Comp->           sig type t = T1.t * T2.t * T3.t val compare : t BatOrd.comp end     end   module Tuple4 :     sig       type ('a, 'b, 'c, 'd) t = 'a * 'b * 'c * 'd       val make : '-> '-> '-> '-> 'a * 'b * 'c * 'd       val first : 'a * 'b * 'c * '-> 'a       val second : 'a * 'b * 'c * '-> 'b       val third : 'a * 'b * 'c * '-> 'c       val fourth : 'a * 'b * 'c * '-> 'd       val get12 : 'a * 'b * 'c * '-> 'a * 'b       val get13 : 'a * 'b * 'c * '-> 'a * 'c       val get14 : 'a * 'b * 'c * '-> 'a * 'd       val get23 : 'a * 'b * 'c * '-> 'b * 'c       val get24 : 'a * 'b * 'c * '-> 'b * 'd       val get34 : 'a * 'b * 'c * '-> 'c * 'd       val get123 : 'a * 'b * 'c * '-> 'a * 'b * 'c       val get124 : 'a * 'b * 'c * '-> 'a * 'b * 'd       val get234 : 'a * 'b * 'c * '-> 'b * 'c * 'd       val map :         ('-> 'e) ->         ('-> 'f) ->         ('-> 'g) -> ('-> 'h) -> 'a * 'b * 'c * '-> 'e * 'f * 'g * 'h       val mapn : ('-> 'b) -> 'a * 'a * 'a * '-> 'b * 'b * 'b * 'b       val map1 : ('-> 'e) -> 'a * 'b * 'c * '-> 'e * 'b * 'c * 'd       val map2 : ('-> 'e) -> 'a * 'b * 'c * '-> 'a * 'e * 'c * 'd       val map3 : ('-> 'e) -> 'a * 'b * 'c * '-> 'a * 'b * 'e * 'd       val map4 : ('-> 'e) -> 'a * 'b * 'c * '-> 'a * 'b * 'c * 'e       val curry : ('a * 'b * 'c * '-> 'e) -> '-> '-> '-> '-> 'e       val uncurry : ('-> '-> '-> '-> 'e) -> 'a * 'b * 'c * '-> 'e       val print :         ?first:string ->         ?sep:string ->         ?last:string ->         ('BatIO.output -> '-> unit) ->         ('BatIO.output -> '-> unit) ->         ('BatIO.output -> '-> unit) ->         ('BatIO.output -> '-> unit) ->         'BatIO.output -> 'a * 'b * 'c * '-> unit       val printn :         ?first:string ->         ?sep:string ->         ?last:string ->         ('BatIO.output -> '-> unit) ->         'BatIO.output -> 'a * 'a * 'a * '-> unit       val compare :         ?cmp1:('-> '-> int) ->         ?cmp2:('-> '-> int) ->         ?cmp3:('-> '-> int) ->         ?cmp4:('-> '-> int) ->         'a * 'b * 'c * '-> 'a * 'b * 'c * '-> int       type 'a enumerable = 'a * 'a * 'a * 'a       val enum : 'a enumerable -> 'BatEnum.t       val of_enum : 'BatEnum.t -> 'a enumerable       val eq :         'BatOrd.eq ->         'BatOrd.eq ->         'BatOrd.eq -> 'BatOrd.eq -> ('a * 'b * 'c * 'd) BatOrd.eq       val ord :         'BatOrd.ord ->         'BatOrd.ord ->         'BatOrd.ord -> 'BatOrd.ord -> ('a * 'b * 'c * 'd) BatOrd.ord       val comp :         'BatOrd.comp ->         'BatOrd.comp ->         'BatOrd.comp -> 'BatOrd.comp -> ('a * 'b * 'c * 'd) BatOrd.comp       module Eq :         functor           (T1 : BatOrd.Eq) (T2 : BatOrd.Eq) (T3 : BatOrd.Eq) (T4 : BatOrd.Eq->           sig type t = T1.t * T2.t * T3.t * T4.t val eq : t BatOrd.eq end       module Ord :         functor           (T1 : BatOrd.Ord) (T2 : BatOrd.Ord) (T3 : BatOrd.Ord) (T4 : BatOrd.Ord->           sig type t = T1.t * T2.t * T3.t * T4.t val ord : t BatOrd.ord end       module Comp :         functor           (T1 : BatOrd.Comp) (T2 : BatOrd.Comp) (T3 : BatOrd.Comp) (T4 : BatOrd.Comp->           sig             type t = T1.t * T2.t * T3.t * T4.t             val compare : t BatOrd.comp           end     end   module Tuple5 :     sig       type ('a, 'b, 'c, 'd, 'e) t = 'a * 'b * 'c * 'd * 'e       val make : '-> '-> '-> '-> '-> 'a * 'b * 'c * 'd * 'e       val first : 'a * 'b * 'c * 'd * '-> 'a       val second : 'a * 'b * 'c * 'd * '-> 'b       val third : 'a * 'b * 'c * 'd * '-> 'c       val fourth : 'a * 'b * 'c * 'd * '-> 'd       val fifth : 'a * 'b * 'c * 'd * '-> 'e       val get12 : 'a * 'b * 'c * 'd * '-> 'a * 'b       val get13 : 'a * 'b * 'c * 'd * '-> 'a * 'c       val get14 : 'a * 'b * 'c * 'd * '-> 'a * 'd       val get15 : 'a * 'b * 'c * 'd * '-> 'a * 'e       val get23 : 'a * 'b * 'c * 'd * '-> 'b * 'c       val get24 : 'a * 'b * 'c * 'd * '-> 'b * 'd       val get25 : 'a * 'b * 'c * 'd * '-> 'b * 'e       val get34 : 'a * 'b * 'c * 'd * '-> 'c * 'd       val get35 : 'a * 'b * 'c * 'd * '-> 'c * 'e       val get45 : 'a * 'b * 'c * 'd * '-> 'd * 'e       val get123 : 'a * 'b * 'c * 'd * '-> 'a * 'b * 'c       val get124 : 'a * 'b * 'c * 'd * '-> 'a * 'b * 'd       val get125 : 'a * 'b * 'c * 'd * '-> 'a * 'b * 'e       val get134 : 'a * 'b * 'c * 'd * '-> 'a * 'c * 'd       val get135 : 'a * 'b * 'c * 'd * '-> 'a * 'c * 'e       val get145 : 'a * 'b * 'c * 'd * '-> 'a * 'd * 'e       val get234 : 'a * 'b * 'c * 'd * '-> 'b * 'c * 'd       val get235 : 'a * 'b * 'c * 'd * '-> 'b * 'c * 'e       val get245 : 'a * 'b * 'c * 'd * '-> 'b * 'd * 'e       val get345 : 'a * 'b * 'c * 'd * '-> 'c * 'd * 'e       val get1234 : 'a * 'b * 'c * 'd * '-> 'a * 'b * 'c * 'd       val get1235 : 'a * 'b * 'c * 'd * '-> 'a * 'b * 'c * 'e       val get1245 : 'a * 'b * 'c * 'd * '-> 'a * 'b * 'd * 'e       val get1345 : 'a * 'b * 'c * 'd * '-> 'a * 'c * 'd * 'e       val get2345 : 'a * 'b * 'c * 'd * '-> 'b * 'c * 'd * 'e       val map :         ('-> 'f) ->         ('-> 'g) ->         ('-> 'h) ->         ('-> 'i) ->         ('-> 'j) -> 'a * 'b * 'c * 'd * '-> 'f * 'g * 'h * 'i * 'j       val mapn :         ('-> 'b) -> 'a * 'a * 'a * 'a * '-> 'b * 'b * 'b * 'b * 'b       val map1 :         ('-> 'f) -> 'a * 'b * 'c * 'd * '-> 'f * 'b * 'c * 'd * 'e       val map2 :         ('-> 'f) -> 'a * 'b * 'c * 'd * '-> 'a * 'f * 'c * 'd * 'e       val map3 :         ('-> 'f) -> 'a * 'b * 'c * 'd * '-> 'a * 'b * 'f * 'd * 'e       val map4 :         ('-> 'f) -> 'a * 'b * 'c * 'd * '-> 'a * 'b * 'c * 'f * 'e       val map5 :         ('-> 'f) -> 'a * 'b * 'c * 'd * '-> 'a * 'b * 'c * 'd * 'f       val curry :         ('a * 'b * 'c * 'd * '-> 'f) -> '-> '-> '-> '-> '-> 'f       val uncurry :         ('-> '-> '-> '-> '-> 'f) -> 'a * 'b * 'c * 'd * '-> 'f       val print :         ?first:string ->         ?sep:string ->         ?last:string ->         ('BatIO.output -> '-> unit) ->         ('BatIO.output -> '-> unit) ->         ('BatIO.output -> '-> unit) ->         ('BatIO.output -> '-> unit) ->         ('BatIO.output -> '-> unit) ->         'BatIO.output -> 'a * 'b * 'c * 'd * '-> unit       val printn :         ?first:string ->         ?sep:string ->         ?last:string ->         ('BatIO.output -> '-> unit) ->         'BatIO.output -> 'a * 'a * 'a * 'a * '-> unit       val compare :         ?cmp1:('-> '-> int) ->         ?cmp2:('-> '-> int) ->         ?cmp3:('-> '-> int) ->         ?cmp4:('-> '-> int) ->         ?cmp5:('-> '-> int) ->         'a * 'b * 'c * 'd * '-> 'a * 'b * 'c * 'd * '-> int       type 'a enumerable = 'a * 'a * 'a * 'a * 'a       val enum : 'a enumerable -> 'BatEnum.t       val of_enum : 'BatEnum.t -> 'a enumerable       val eq :         'BatOrd.eq ->         'BatOrd.eq ->         'BatOrd.eq ->         'BatOrd.eq -> 'BatOrd.eq -> ('a * 'b * 'c * 'd * 'e) BatOrd.eq       val ord :         'BatOrd.ord ->         'BatOrd.ord ->         'BatOrd.ord ->         'BatOrd.ord -> 'BatOrd.ord -> ('a * 'b * 'c * 'd * 'e) BatOrd.ord       val comp :         'BatOrd.comp ->         'BatOrd.comp ->         'BatOrd.comp ->         'BatOrd.comp ->         'BatOrd.comp -> ('a * 'b * 'c * 'd * 'e) BatOrd.comp       module Eq :         functor           (T1 : BatOrd.Eq) (T2 : BatOrd.Eq) (T3 : BatOrd.Eq) (T4 : BatOrd.Eq) (T5 : BatOrd.Eq->           sig             type t = T1.t * T2.t * T3.t * T4.t * T5.t             val eq : t BatOrd.eq           end       module Ord :         functor           (T1 : BatOrd.Ord) (T2 : BatOrd.Ord) (T3 : BatOrd.Ord) (T4 : BatOrd.Ord) (T5 : BatOrd.Ord->           sig             type t = T1.t * T2.t * T3.t * T4.t * T5.t             val ord : t BatOrd.ord           end       module Comp :         functor           (T1 : BatOrd.Comp) (T2 : BatOrd.Comp) (T3 : BatOrd.Comp) (T4 : BatOrd.Comp) (T5 : BatOrd.Comp->           sig             type t = T1.t * T2.t * T3.t * T4.t * T5.t             val compare : t BatOrd.comp           end     end end