module Targetint:sig..end
   This module provides operations on the type of
   signed 32-bit integers (on 32-bit target platforms) or
   signed 64-bit integers (on 64-bit target platforms).
   This integer type has exactly the same width as that of a
   pointer type in the C compiler.  All arithmetic operations over
   are taken modulo 232 or 264 depending
   on the word size of the target architecture.
type 
val zero : tval one : tval minus_one : tval neg : t -> tval add : t -> t -> tval sub : t -> t -> tval mul : t -> t -> tval div : t -> t -> tDivision_by_zero if the second
   argument is zero.  This division rounds the real quotient of
   its arguments towards zero, as specified for (/).val rem : t -> t -> ty is not zero, the result
   of Targetint.rem x y satisfies the following properties:
   Targetint.zero <= Nativeint.rem x y < Targetint.abs y and
   x = Targetint.add (Targetint.mul (Targetint.div x y) y)
                      (Targetint.rem x y).
   If y = 0, Targetint.rem x y raises Division_by_zero.val succ : t -> tTargetint.succ x is Targetint.add x Targetint.one.val pred : t -> tTargetint.pred x is Targetint.sub x Targetint.one.val abs : t -> tval size : intval max_int : tval min_int : tval logand : t -> t -> tval logor : t -> t -> tval logxor : t -> t -> tval lognot : t -> tval shift_left : t -> int -> tTargetint.shift_left x y shifts x to the left by y bits.
    The result is unspecified if y < 0 or y >= bitsize,
    where bitsize is 32 on a 32-bit platform and
    64 on a 64-bit platform.val shift_right : t -> int -> tTargetint.shift_right x y shifts x to the right by y bits.
    This is an arithmetic shift: the sign bit of x is replicated
    and inserted in the vacated bits.
    The result is unspecified if y < 0 or y >= bitsize.val shift_right_logical : t -> int -> tTargetint.shift_right_logical x y shifts x to the right
    by y bits.
    This is a logical shift: zeroes are inserted in the vacated bits
    regardless of the sign of x.
    The result is unspecified if y < 0 or y >= bitsize.val of_int : int -> tint) to a target integer
    (type t), module the target word size.val of_int_exn : int -> tint) to a target integer
    (type t).  Raises a fatal error if the conversion is not exact.val to_int : t -> intt) to an
    integer (type int).  The high-order bit is lost during
    the conversion.val of_float : float -> tTargetint.min_int, Targetint.max_int].val to_float : t -> floatval of_int32 : int32 -> tint32)
    to a target integer.val to_int32 : t -> int32int32).  On 64-bit platforms,
    the 64-bit native integer is taken modulo 232,
    i.e. the top 32 bits are lost.  On 32-bit platforms,
    the conversion is exact.val of_int64 : int64 -> tint64)
    to a target integer.val to_int64 : t -> int64int64).val of_string : string -> t0x, 0o or 0b
    respectively.
    Raise Failure "int_of_string" if the given string is not
    a valid representation of an integer, or if the integer represented
    exceeds the range of integers representable in type nativeint.val to_string : t -> stringval compare : t -> t -> intcompare.  Along with the type t, this function compare
    allows the module Targetint to be passed as argument to the functors
    Set.Make and Map.Make.val equal : t -> t -> booltype | | | Int32 of  | 
| | | Int64 of  | 
val repr : t -> repr