# OpCodes.Div Field

## Definition

Divides two values and pushes the result as a floating-point (type `F`) or quotient (type `int32`) onto the evaluation stack.

``public: static initonly System::Reflection::Emit::OpCode Div;``
``public static readonly System.Reflection.Emit.OpCode Div;``
`` staticval mutable Div : System.Reflection.Emit.OpCode``
``Public Shared ReadOnly Div As OpCode ``

OpCode

## Remarks

The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:

Format Assembly Format Description
5B div Divides two values to return a quotient or floating-point result.

The stack transitional behavior, in sequential order, is:

1. `value1` is pushed onto the stack.

2. `value2` is pushed onto the stack.

3. `value2` and `value1` are popped from the stack; `value1` is divided by `value2`.

4. The result is pushed onto the stack.

`result` = `value1` div value2 satisfies the following conditions:

| `result` | = | `value1` | / | `value2` |, and:

sign(`result`) = +, if sign(`value1`) = sign(`value2`), or -, if sign(`value1`) ~= sign(`value2`)

The `div` instruction computes the result and pushes it on the stack.

Integer division truncates towards zero.

Division of a finite number by zero produces the correctly signed infinite value.

Dividing zero by zero or infinity by infinity produces the NaN (Not-A-Number) value. Any number divided by infinity will produce a zero value.

Integral operations throw ArithmeticException if the result cannot be represented in the result type. This can happen if `value1` is the maximum negative value, and `value2` is -1.

Integral operations throw DivideByZeroException if `value2` is zero.

Note that on Intel-based platforms an OverflowException is thrown when computing (minint div -1). Floating-point operations never throw an exception (they produce NaNs or infinities instead).

The following Emit method overload can use the `div` opcode: