# dmd.common.int128

- `tst`

  #### Declaration

  `pure nothrow @nogc @safe bool `tst`(Cent `c`);`

  Test against 0

  #### Parameters

  `Cent `c`` | Cent to test

  #### Return Value

  `true` if != 0

- `com`

  #### Declaration

  `pure nothrow @nogc @safe Cent `com`(Cent `c`);`

  Complement

  #### Parameters

  `Cent `c`` | Cent to complement

  #### Return Value

  complemented value

- `neg`

  #### Declaration

  `pure nothrow @nogc @safe Cent `neg`(Cent `c`);`

  Negate

  #### Parameters

  `Cent `c`` | Cent to negate

  #### Return Value

  negated value

- `inc`

  #### Declaration

  `pure nothrow @nogc @safe Cent `inc`(Cent `c`);`

  Increment

  #### Parameters

  `Cent `c`` | Cent to increment

  #### Return Value

  incremented value

- `dec`

  #### Declaration

  `pure nothrow @nogc @safe Cent `dec`(Cent `c`);`

  Decrement

  #### Parameters

  `Cent `c`` | Cent to decrement

  #### Return Value

  incremented value

- `shl1`

  #### Declaration

  `pure nothrow @nogc @safe Cent `shl1`(Cent `c`);`

  Shift left one bit

  #### Parameters

  `Cent `c`` | Cent to shift

  #### Return Value

  shifted value

- `shr1`

  #### Declaration

  `pure nothrow @nogc @safe Cent `shr1`(Cent `c`);`

  Unsigned shift right one bit

  #### Parameters

  `Cent `c`` | Cent to shift

  #### Return Value

  shifted value

- `sar1`

  #### Declaration

  `pure nothrow @nogc @safe Cent `sar1`(Cent `c`);`

  Arithmetic shift right one bit

  #### Parameters

  `Cent `c`` | Cent to shift

  #### Return Value

  shifted value

- `shl`

  #### Declaration

  `pure nothrow @nogc @safe Cent `shl`(Cent `c`, uint `n`);`

  Shift left `n` bits

  #### Parameters

  `Cent `c`` | Cent to shift
  `uint `n`` | number of bits to shift

  #### Return Value

  shifted value

- `shr`

  #### Declaration

  `pure nothrow @nogc @safe Cent `shr`(Cent `c`, uint `n`);`

  Unsigned shift right `n` bits

  #### Parameters

  `Cent `c`` | Cent to shift
  `uint `n`` | number of bits to shift

  #### Return Value

  shifted value

- `sar`

  #### Declaration

  `pure nothrow @nogc @safe Cent `sar`(Cent `c`, uint `n`);`

  Arithmetic shift right `n` bits

  #### Parameters

  `Cent `c`` | Cent to shift
  `uint `n`` | number of bits to shift

  #### Return Value

  shifted value

- `rol1`

  #### Declaration

  `pure nothrow @nogc @safe Cent `rol1`(Cent `c`);`

  Rotate left one bit

  #### Parameters

  `Cent `c`` | Cent to rotate

  #### Return Value

  rotated value

- `ror1`

  #### Declaration

  `pure nothrow @nogc @safe Cent `ror1`(Cent `c`);`

  Rotate right one bit

  #### Parameters

  `Cent `c`` | Cent to rotate

  #### Return Value

  rotated value

- `rol`

  #### Declaration

  `pure nothrow @nogc @safe Cent `rol`(Cent `c`, uint `n`);`

  Rotate left `n` bits

  #### Parameters

  `Cent `c`` | Cent to rotate
  `uint `n`` | number of bits to rotate

  #### Return Value

  rotated value

- `ror`

  #### Declaration

  `pure nothrow @nogc @safe Cent `ror`(Cent `c`, uint `n`);`

  Rotate right `n` bits

  #### Parameters

  `Cent `c`` | Cent to rotate
  `uint `n`` | number of bits to rotate

  #### Return Value

  rotated value

- `and`

  #### Declaration

  `pure nothrow @nogc @safe Cent `and`(Cent `c1`, Cent `c2`);`

  And `c1` & `c2`.

  #### Parameters

  `Cent `c1`` | operand 1
  `Cent `c2`` | operand 2

  #### Return Value

  `c1` & `c2`

- `or`

  #### Declaration

  `pure nothrow @nogc @safe Cent `or`(Cent `c1`, Cent `c2`);`

  Or `c1` | `c2`.

  #### Parameters

  `Cent `c1`` | operand 1
  `Cent `c2`` | operand 2

  #### Return Value

  `c1` | `c2`

- `xor`

  #### Declaration

  `pure nothrow @nogc @safe Cent `xor`(Cent `c1`, Cent `c2`);`

  Xor `c1` ^ `c2`.

  #### Parameters

  `Cent `c1`` | operand 1
  `Cent `c2`` | operand 2

  #### Return Value

  `c1` ^ `c2`

- `add`

  #### Declaration

  `pure nothrow @nogc @safe Cent `add`(Cent `c1`, Cent `c2`);`

  Add `c1` to `c2`.

  #### Parameters

  `Cent `c1`` | operand 1
  `Cent `c2`` | operand 2

  #### Return Value

  `c1` + `c2`

- `sub`

  #### Declaration

  `pure nothrow @nogc @safe Cent `sub`(Cent `c1`, Cent `c2`);`

  Subtract `c2` from `c1`.

  #### Parameters

  `Cent `c1`` | operand 1
  `Cent `c2`` | operand 2

  #### Return Value

  `c1` - `c2`

- `mul`

  #### Declaration

  `pure nothrow @nogc @safe Cent `mul`(Cent `c1`, Cent `c2`);`

  Multiply `c1` * `c2`.

  #### Parameters

  `Cent `c1`` | operand 1
  `Cent `c2`` | operand 2

  #### Return Value

  `c1` * `c2`

- `udiv`

  #### Declaration

  `pure nothrow @nogc @safe Cent `udiv`(Cent `c1`, Cent `c2`);`

  Unsigned divide `c1` / `c2`.

  #### Parameters

  `Cent `c1`` | dividend
  `Cent `c2`` | divisor

  #### Return Value

  quotient `c1` / `c2`

- `udivmod`

  #### Declaration

  `pure nothrow @nogc @safe Cent `udivmod`(Cent `c1`, Cent `c2`, out Cent `modulus`);`

  Unsigned divide `c1` / `c2`. The remainder after division is stored to `modulus`.

  #### Parameters

  `Cent `c1`` | dividend
  `Cent `c2`` | divisor
  `Cent `modulus`` | set to `c1` % `c2`

  #### Return Value

  quotient `c1` / `c2`

- `div`

  #### Declaration

  `pure nothrow @nogc @safe Cent `div`(Cent `c1`, Cent `c2`);`

  Signed divide `c1` / `c2`.

  #### Parameters

  `Cent `c1`` | dividend
  `Cent `c2`` | divisor

  #### Return Value

  quotient `c1` / `c2`

- `divmod`

  #### Declaration

  `pure nothrow @nogc @safe Cent `divmod`(Cent `c1`, Cent `c2`, out Cent `modulus`);`

  Signed divide `c1` / `c2`. The remainder after division is stored to `modulus`.

  #### Parameters

  `Cent `c1`` | dividend
  `Cent `c2`` | divisor
  `Cent `modulus`` | set to `c1` % `c2`

  #### Return Value

  quotient `c1` / `c2`

- `ugt`

  #### Declaration

  `pure nothrow @nogc @safe bool `ugt`(Cent `c1`, Cent `c2`);`

  If `c1` > `c2` unsigned

  #### Parameters

  `Cent `c1`` | operand 1
  `Cent `c2`` | operand 2

  #### Return Value

  `true` if `c1` > `c2`

- `uge`

  #### Declaration

  `pure nothrow @nogc @safe bool `uge`(Cent `c1`, Cent `c2`);`

  If `c1` >= `c2` unsigned

  #### Parameters

  `Cent `c1`` | operand 1
  `Cent `c2`` | operand 2

  #### Return Value

  `true` if `c1` >= `c2`

- `ult`

  #### Declaration

  `pure nothrow @nogc @safe bool `ult`(Cent `c1`, Cent `c2`);`

  If `c1` < `c2` unsigned

  #### Parameters

  `Cent `c1`` | operand 1
  `Cent `c2`` | operand 2

  #### Return Value

  `true` if `c1` < `c2`

- `ule`

  #### Declaration

  `pure nothrow @nogc @safe bool `ule`(Cent `c1`, Cent `c2`);`

  If `c1` <= `c2` unsigned

  #### Parameters

  `Cent `c1`` | operand 1
  `Cent `c2`` | operand 2

  #### Return Value

  `true` if `c1` <= `c2`

- `gt`

  #### Declaration

  `pure nothrow @nogc @safe bool `gt`(Cent `c1`, Cent `c2`);`

  If `c1` > `c2` signed

  #### Parameters

  `Cent `c1`` | operand 1
  `Cent `c2`` | operand 2

  #### Return Value

  `true` if `c1` > `c2`

- `ge`

  #### Declaration

  `pure nothrow @nogc @safe bool `ge`(Cent `c1`, Cent `c2`);`

  If `c1` >= `c2` signed

  #### Parameters

  `Cent `c1`` | operand 1
  `Cent `c2`` | operand 2

  #### Return Value

  `true` if `c1` >= `c2`

- `lt`

  #### Declaration

  `pure nothrow @nogc @safe bool `lt`(Cent `c1`, Cent `c2`);`

  If `c1` < `c2` signed

  #### Parameters

  `Cent `c1`` | operand 1
  `Cent `c2`` | operand 2

  #### Return Value

  `true` if `c1` < `c2`

- `le`

  #### Declaration

  `pure nothrow @nogc @safe bool `le`(Cent `c1`, Cent `c2`);`

  If `c1` <= `c2` signed

  #### Parameters

  `Cent `c1`` | operand 1
  `Cent `c2`` | operand 2

  #### Return Value

  `true` if `c1` <= `c2`