A cross-platform signed 64-bit integer. Int64 instances can be created from two 32-bit words using `Int64.make()`.

### `@:keep@:op(A + B)staticinlineadd(a:Int64, b:Int64):Int64`

Returns the sum of `a` and `b`.

### `@:keep@:op(A & B)staticinlineand(a:Int64, b:Int64):Int64`

Returns the bitwise AND of `a` and `b`.

### `@:keepstaticinlinecompare(a:Int64, b:Int64):Int`

Compares `a` and `b` in signed mode. Returns a negative value if `a < b`, positive if `a > b`, or 0 if `a == b`.

### `@:keepstaticinlinecopy(this:__Int64):Int64`

Makes a copy of `this` Int64.

### `@:keep@:op(A / B)staticinlinediv(a:Int64, b:Int64):Int64`

Returns the quotient of `a` divided by `b`.

### `@:keepstaticdivMod(dividend:Int64, divisor:Int64):{quotient:Int64, modulus:Int64}`

Performs signed integer divison of `dividend` by `divisor`. Returns `{ quotient : Int64, modulus : Int64 }`.

### `@:keep@:op(A == B)staticinlineeq(a:Int64, b:Int64):Bool`

Returns `true` if `a` is equal to `b`.

### `@:keepstaticinlinegetHigh(x:Int64):Int32`

Returns the high 32-bit word of `x`.

### `@:keepstaticinlinegetLow(x:Int64):Int32`

Returns the low 32-bit word of `x`.

### `@:keepstaticinlineis(val:Dynamic):Bool`

Deprecated: "haxe.Int64.is() is deprecated. Use haxe.Int64.isInt64() instead"

### `@:keepstaticinlineisInt64(val:Dynamic):Bool`

Returns whether the value `val` is of type `haxe.Int64`

### `@:keepstaticinlineisNeg(x:Int64):Bool`

Returns `true` if `x` is less than zero.

### `@:keepstaticinlineisZero(x:Int64):Bool`

Returns `true` if `x` is exactly zero.

### `@:keepstaticinlinemake(high:Int32, low:Int32):Int64`

Construct an Int64 from two 32-bit words `high` and `low`.

### `@:keep@:op(A % B)staticinlinemod(a:Int64, b:Int64):Int64`

Returns the modulus of `a` divided by `b`.

### `@:keep@:op(A * B)staticmul(a:Int64, b:Int64):Int64`

Returns the product of `a` and `b`.

### `@:keep@:op(-A)staticneg(x:Int64):Int64`

Returns the negative of `x`.

### `@:keep@:op(A != B)staticinlineneq(a:Int64, b:Int64):Bool`

Returns `true` if `a` is not equal to `b`.

### `@:keep@:fromstaticinlineofInt(x:Int):Int64`

Returns an Int64 with the value of the Int `x`. `x` is sign-extended to fill 64 bits.

### `@:keep@:op(A | B)staticinlineor(a:Int64, b:Int64):Int64`

Returns the bitwise OR of `a` and `b`.

### `@:keep@:op(A << B)staticinlineshl(a:Int64, b:Int):Int64`

Returns `a` left-shifted by `b` bits.

### `@:keep@:op(A >> B)staticinlineshr(a:Int64, b:Int):Int64`

Returns `a` right-shifted by `b` bits in signed mode. `a` is sign-extended.

### `@:keep@:op(A - B)staticinlinesub(a:Int64, b:Int64):Int64`

Returns `a` minus `b`.

### `@:keepstaticinlinetoInt(x:Int64):Int`

Returns an Int with the value of the Int64 `x`. Throws an exception if `x` cannot be represented in 32 bits.

### `@:keepstaticinlinetoStr(x:Int64):String`

Returns a signed decimal `String` representation of `x`.

### `@:keepstaticinlineucompare(a:Int64, b:Int64):Int`

Compares `a` and `b` in unsigned mode. Returns a negative value if `a < b`, positive if `a > b`, or 0 if `a == b`.

### `@:keep@:op(A >>> B)staticinlineushr(a:Int64, b:Int):Int64`

Returns `a` right-shifted by `b` bits in unsigned mode. `a` is padded with zeroes.

### `@:keep@:op(A ^ B)staticinlinexor(a:Int64, b:Int64):Int64`

Returns the bitwise XOR of `a` and `b`.