# Module Gmp.Z

    module Z: sig .. end

    type t = Gmp.Z2.t

    val copy : t -> t

    val from_int : int -> t

    val of_int : int -> t

    val from_string_base : base:int -> string -> t

    val from_float : float -> t

    val of_float : float -> t

    val to_string_base : base:int -> t -> string

    val to_int : t -> int

    val to_float : t -> float

    val int_from : t -> int

    val float_from : t -> float

    val add : t -> t -> t

    val sub : t -> t -> t

    val mul : t -> t -> t

    val add_ui : t -> int -> t

    val sub_ui : t -> int -> t

    val mul_ui : t -> int -> t

    val neg : t -> t

    val abs : t -> t

    val tdiv_qr : t -> t -> t * t

    val tdiv_q : t -> t -> t

    val tdiv_r : t -> t -> t

    val cdiv_qr : t -> t -> t * t

    val cdiv_q : t -> t -> t

    val cdiv_r : t -> t -> t

    val fdiv_qr : t -> t -> t * t

    val fdiv_q : t -> t -> t

    val fdiv_r : t -> t -> t

    val dmod : t -> t -> t

    val dmod_ui : t -> int -> t

    val euclidean_division : t -> t -> t * t

    val modulo : t -> t -> t

    val tdiv_qr_ui : t -> int -> t * t

    val tdiv_q_ui : t -> int -> t

    val tdiv_r_ui : t -> int -> t

    val tdiv_ui : t -> int -> int

    val cdiv_qr_ui : t -> int -> t * t

    val cdiv_q_ui : t -> int -> t

    val cdiv_r_ui : t -> int -> t

    val cdiv_ui : t -> int -> int

    val fdiv_qr_ui : t -> int -> t * t

    val fdiv_q_ui : t -> int -> t

    val fdiv_r_ui : t -> int -> t

    val fdiv_ui : t -> int -> int

    val divexact : t -> t -> t

    val mul_2exp : t -> int -> t

    val mul2exp : t -> int -> t

    val tdiv_q_2exp : t -> int -> t

    val tdiv_r_2exp : t -> int -> t

    val fdiv_q_2exp : t -> int -> t

    val fdiv_r_2exp : t -> int -> t

    val cdiv_q_2exp : t -> int -> t

    val cdiv_r_2exp : t -> int -> t

    val powm : t -> t -> t -> t

    val powm_ui : t -> int -> t -> t

    val pow_ui : t -> int -> t

    val ui_pow_ui : int -> int -> t

    val pow_ui_ui : int -> int -> t

    val sqrt : t -> t

    val sqrtrem : t -> t * t

    val root : t -> int -> t

    val perfect_power_p : t -> bool

    val perfect_square_p : t -> bool

    val is_perfect_power : t -> bool

    val is_perfect_square : t -> bool

    val probab_prime_p : t -> int -> bool

    val is_probab_prime : t -> int -> bool

    val nextprime : t -> t

    val gcd : t -> t -> t

    val gcd_ui : t -> t -> t

    val lcm : t -> t -> t

    val gcdext : t -> t -> t * t * t

    val inverse : t -> t -> t option

    val legendre : t -> t -> int

    val jacobi : t -> t -> int

    val kronecker_si : t -> int -> int

    val si_kronecker : int -> t -> int

    val remove : t -> t -> t * int

    val fac_ui : int -> t

    val fib_ui : int -> t

    val bin_ui : n:t -> k:int -> t

    val bin_uiui : n:int -> k:int -> t

    val cmp : t -> t -> int

    val cmp_si : t -> int -> int

    val compare : t -> t -> int

    val compare_si : t -> int -> int

    val compare_int : t -> int -> int

    val sgn : t -> int

    val band : t -> t -> t

    val bior : t -> t -> t

    val bxor : t -> t -> t

    val bcom : t -> t

    val popcount : t -> int

    val hamdist : t -> t -> int

    val scan0 : t -> int -> int

    val scan1 : t -> int -> int

    val urandomb : state:Gmp.RNG.randstate_t -> nbits:int -> t

    val urandomm : state:Gmp.RNG.randstate_t -> n:t -> t

    val rrandomb : state:Gmp.RNG.randstate_t -> nbits:int -> t

    val zero : t

    val one : t

    val is_prime : ?prec:int -> t -> bool

    val equal : t -> t -> bool

    val equal_int : t -> int -> bool

    val is_zero : t -> bool

    val to_string : t -> string

    val from_string : string -> t

    val string_from : t -> string

    val output : Stdlib.out_channel -> t -> unit

    val sprintf : unit -> t -> string

    val print : Stdlib.Format.formatter -> t -> unit

    val succ : t -> t

    val pred : t -> t

    val min : t -> t -> t

    val max : t -> t -> t

    module Infixes: sig .. end