/*
     File:       Math64.h
 
     Contains:   64-bit integer math Interfaces.
 
     Version:    Technology: Mac OS 9
                 Release:    Universal Interfaces 3.4
 
     Copyright:  © 1994-2001 by Apple Computer, Inc., all rights reserved
 
     Bugs?:      For bug reports, consult the following page on
                 the World Wide Web:
 
                     http://developer.apple.com/bugreporter/
 
*/
#ifndef __MATH64__
#define __MATH64__

#ifndef __CONDITIONALMACROS__
#include <ConditionalMacros.h>
#endif

#ifndef __MACTYPES__
#include <MacTypes.h>
#endif




#if PRAGMA_ONCE
#pragma once
#endif

#ifdef __cplusplus
extern "C" {
#endif

#if PRAGMA_IMPORT
#pragma import on
#endif

#if PRAGMA_STRUCT_ALIGN
    #pragma options align=mac68k
#elif PRAGMA_STRUCT_PACKPUSH
    #pragma pack(push, 2)
#elif PRAGMA_STRUCT_PACK
    #pragma pack(2)
#endif


/*
 *  S64Max()
 *  
 *  Discussion:
 *    Returns largest possible SInt64 value
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( SInt64 )
S64Max(void);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline SInt64 S64Max(void) { return 9223372036854775807LL; }
  #else
    #define S64Max() (9223372036854775807LL)
  #endif
#endif


#if defined(__MWERKS__) && (__MWERKS__ < 0x1800) && defined(S64Max)
/* older Metrowerks compilers errored on LL suffix */
 #undef S64Max
 #define S64Max() 9223372036854775807
#endif
/*
 *  S64Min()
 *  
 *  Discussion:
 *    Returns smallest possible SInt64 value
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( SInt64 )
S64Min(void);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline SInt64 S64Min(void) { return -S64Max() - 1; }
  #else
    #define S64Min() (-S64Max() - 1)
  #endif
#endif



/*
 *  S64Add()
 *  
 *  Discussion:
 *    Adds two integers, producing an integer result.  If an overflow
 *    occurs the result is congruent mod (2^64) as if the operands and
 *    result were unsigned.  No overflow is signaled.
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( SInt64 )
S64Add(
  SInt64   left,
  SInt64   right);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline SInt64 S64Add(SInt64 left, SInt64 right) { return (SInt64)(left) + (SInt64)(right); }
  #else
    #define S64Add(left, right) ((SInt64)(left) + (SInt64)(right))
  #endif
#endif



/*
 *  S64Subtract()
 *  
 *  Discussion:
 *    Subtracts two integers, producing an integer result.  If an
 *    overflow occurs the result is congruent mod (2^64) as if the
 *    operands and result were unsigned.  No overflow is signaled.
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( SInt64 )
S64Subtract(
  SInt64   left,
  SInt64   right);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline SInt64 S64Subtract(SInt64 left, SInt64 right) { return (SInt64)(left) - (SInt64)(right); }
  #else
    #define S64Subtract(left, right) ((SInt64)(left) - (SInt64)(right))
  #endif
#endif



/*
 *  S64Negate()
 *  
 *  Discussion:
 *    Returns the additive inverse of a signed number (i.e. it returns
 *    0 - the number).  S64Negate (S64Min) is not representable (in
 *    fact, it returns S64Min).
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( SInt64 )
S64Negate(SInt64 value);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline SInt64 S64Negate(SInt64 value) { return -(SInt64)(value); }
  #else
    #define S64Negate(value) (-(SInt64)(value))
  #endif
#endif



#if !TYPE_LONGLONG
/*
 *  S64Absolute()
 *  
 *  Discussion:
 *    Returns the absolute value of the number (i.e. the number if it
 *    is positive, or 0 - the number if it is negative). Disabled for
 *    compilers that support long long until llabs() is available
 *    everywhere.
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( SInt64 )
S64Absolute(SInt64 value);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline SInt64 S64Absolute(SInt64 value) { return llabs((SInt64)value); }
  #else
    #define S64Absolute(value) (llabs((SInt64)value))
  #endif
#endif


#endif  /* !TYPE_LONGLONG */

/*
 *  S64Multiply()
 *  
 *  Discussion:
 *    Multiplies two signed numbers, producing a signed result. 
 *    Overflow is ignored and the low-order part of the product is
 *    returned.  The sign of the result is not guaranteed to be correct
 *    if the magnitude of the product is not representable.
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( SInt64 )
S64Multiply(
  SInt64   left,
  SInt64   right);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline SInt64 S64Multiply(SInt64 left, SInt64 right) { return (SInt64)(left) * (SInt64)(right); }
  #else
    #define S64Multiply(left, right) ((SInt64)(left) * (SInt64)(right))
  #endif
#endif



#if CALL_NOT_IN_CARBON
/*
 *  S64Mod()
 *  
 *  Discussion:
 *    Returns the remainder of divide of dividend by divisor.  The sign
 *    of the remainder is the same as the sign of the dividend (i.e.,
 *    it takes the absolute values of the operands, does the division,
 *    then fixes the sign of the quotient and remainder).
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( SInt64 )
S64Mod(
  SInt64   dividend,
  SInt64   divisor);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline SInt64 S64Mod(SInt64 dividend, SInt64 divisor) { return (SInt64)(dividend) % (SInt64)(divisor); }
  #else
    #define S64Mod(dividend, divisor) ((SInt64)(dividend) % (SInt64)(divisor))
  #endif
#endif




#endif  /* CALL_NOT_IN_CARBON */

/*
 *  S64Divide()
 *  
 *  Discussion:
 *    Divides dividend by divisor, returning the quotient.  The
 *    remainder is returned in *remainder if remainder (the pointer) is
 *    non-NULL. The sign of the remainder is the same as the sign of
 *    the dividend (i.e. it takes the absolute values of the operands,
 *    does the division, then fixes the sign of the quotient and
 *    remainder).  If the divisor is zero, then S64Max() will be
 *    returned (or S64Min() if the dividend is negative), and the
 *    remainder will be the dividend; no error is reported.
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( SInt64 )
S64Divide(
  SInt64    dividend,
  SInt64    divisor,
  SInt64 *  remainder);      /* can be NULL */
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline SInt64 S64Divide(SInt64 dividend, SInt64 divisor, SInt64 *remainder) { return ((remainder) ? (*((SInt64*)(remainder)) = ((SInt64)(dividend) % (SInt64)(divisor))) : 0), ((SInt64)(dividend) / (SInt64)(divisor)); }
  #else
    #define S64Divide(dividend, divisor, remainder) (((remainder) ? (*((SInt64*)(remainder)) = ((SInt64)(dividend) % (SInt64)(divisor))) : 0), ((SInt64)(dividend) / (SInt64)(divisor)))
  #endif
#endif



#ifdef __cplusplus
  inline SInt64 S64Div(SInt64 dividend, SInt64 divisor) { return S64Divide((dividend), (divisor), NULL); }
#else
  #define S64Div(dividend, divisor) (S64Divide((dividend), (divisor), NULL))
#endif

/*
 *  S64Set()
 *  
 *  Discussion:
 *    Given an SInt32, returns an SInt64 with the same value.  Use this
 *    routine instead of coding 64-bit constants (at least when the
 *    constant will fit in an SInt32).
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( SInt64 )
S64Set(SInt32 value);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline SInt64 S64Set(SInt32 value) { return (SInt64)(value); }
  #else
    #define S64Set(value) ((SInt64)(value))
  #endif
#endif



/*
 *  S64SetU()
 *  
 *  Discussion:
 *    Given a UInt32, returns a SInt64 with the same value.
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( SInt64 )
S64SetU(UInt32 value);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline SInt64 S64SetU(UInt32 value) { return (SInt64)(value); }
  #else
    #define S64SetU(value) ((SInt64)(value))
  #endif
#endif


/*
 *  S32Set()
 *  
 *  Discussion:
 *    Given an SInt64, returns an SInt32 by discarding the high-order
 *    32 bits.
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( SInt32 )
S32Set(SInt64 value);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline SInt32 S32Set(SInt64 value) { return (SInt32)(value); }
  #else
    #define S32Set(value) ((SInt32)(value))
  #endif
#endif



/*
 *  S64And()
 *  
 *  Discussion:
 *    Returns one if left and right are non-zero, otherwise returns zero
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( Boolean )
S64And(
  SInt64   left,
  SInt64   right);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline Boolean S64And(SInt64 left, SInt64 right) { return (SInt64)(left) && (SInt64)(right); }
  #else
    #define S64And(left, right) ((SInt64)(left) && (SInt64)(right))
  #endif
#endif



/*
 *  S64Or()
 *  
 *  Discussion:
 *    Returns one if left or right are non-zero, otherwise returns zero
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( Boolean )
S64Or(
  SInt64   left,
  SInt64   right);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline Boolean S64Or(SInt64 left, SInt64 right) { return (SInt64)(left) || (SInt64)(right); }
  #else
    #define S64Or(left, right) ((SInt64)(left) || (SInt64)(right))
  #endif
#endif



/*
 *  S64Eor()
 *  
 *  Discussion:
 *    Returns one if left xor right are non-zero, otherwise returns zero
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( Boolean )
S64Eor(
  SInt64   left,
  SInt64   right);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline Boolean S64Eor(SInt64 left, SInt64 right) { return (Boolean)(((SInt64)(left) ? 1 : 0) ^ ((SInt64)(right) ? 1 : 0)); }
  #else
    #define S64Eor(left, right) ((Boolean)(((SInt64)(left) ? 1 : 0) ^ ((SInt64)(right) ? 1 : 0)))
  #endif
#endif



/*
 *  S64Not()
 *  
 *  Discussion:
 *    Returns one if value is non-zero, otherwisze returns zero.
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( Boolean )
S64Not(SInt64 value);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline Boolean S64Not(SInt64 value) { return !((SInt64)(value)); }
  #else
    #define S64Not(value) (!((SInt64)(value)))
  #endif
#endif



/*
 *  S64Compare()
 *  
 *  Discussion:
 *    Given two signed numbers, left and right, returns an SInt32 that
 *    compares with zero the same way left compares with right.  If you
 *    wanted to perform a comparison on 64-bit integers of the
 *    form:
 *    operand_1 <operation> operand_2
 *    then you could use an expression of the form:
 *     xxxS64Compare(operand_1,operand_2) <operation> 0
 *    to test for the same condition. CAUTION: DO NOT depend on the
 *    exact value returned by this routine. Only the sign (i.e.
 *    positive, zero, or negative) of the result is guaranteed.
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( SInt32 )
S64Compare(
  SInt64   left,
  SInt64   right);



/*
 *  S64BitwiseAnd()
 *  
 *  Discussion:
 *    bitwise AND
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( SInt64 )
S64BitwiseAnd(
  SInt64   left,
  SInt64   right);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline SInt64 S64BitwiseAnd(SInt64 left, SInt64 right) { return (SInt64)(left) & (SInt64)(right); }
  #else
    #define S64BitwiseAnd(left, right) ((SInt64)(left) & (SInt64)(right))
  #endif
#endif



/*
 *  S64BitwiseOr()
 *  
 *  Discussion:
 *    bitwise OR
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( SInt64 )
S64BitwiseOr(
  SInt64   left,
  SInt64   right);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline SInt64 S64BitwiseOr(SInt64 left, SInt64 right) { return (SInt64)(left) | (SInt64)(right); }
  #else
    #define S64BitwiseOr(left, right) ((SInt64)(left) | (SInt64)(right))
  #endif
#endif



/*
 *  S64BitwiseEor()
 *  
 *  Discussion:
 *    bitwise XOR
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( SInt64 )
S64BitwiseEor(
  SInt64   left,
  SInt64   right);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline SInt64 S64BitwiseEor(SInt64 left, SInt64 right) { return (SInt64)(left) ^ (SInt64)(right); }
  #else
    #define S64BitwiseEor(left, right) ((SInt64)(left) ^ (SInt64)(right))
  #endif
#endif



/*
 *  S64BitwiseNot()
 *  
 *  Discussion:
 *    bitwise negate
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( SInt64 )
S64BitwiseNot(SInt64 value);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline SInt64 S64BitwiseNot(SInt64 value) { return ~((SInt64)(value)); }
  #else
    #define S64BitwiseNot(value) (~((SInt64)(value)))
  #endif
#endif



/*
 *  S64ShiftRight()
 *  
 *  Discussion:
 *    Arithmetic shift of value by the lower 7 bits of the shift.
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( SInt64 )
S64ShiftRight(
  SInt64   value,
  UInt32   shift);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline SInt64 S64ShiftRight(SInt64 value, UInt32 shift) { return (SInt64)(value) >> ((shift) & 0x7F); }
  #else
    #define S64ShiftRight(value, shift) ((SInt64)(value) >> ((shift) & 0x7F))
  #endif
#endif



/*
 *  S64ShiftLeft()
 *  
 *  Discussion:
 *    Logical shift of value by the lower 7 bits of the shift.
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( SInt64 )
S64ShiftLeft(
  SInt64   value,
  UInt32   shift);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline SInt64 S64ShiftLeft(SInt64 value, UInt32 shift) { return (SInt64)(value) << ((shift) & 0x7F); }
  #else
    #define S64ShiftLeft(value, shift) ((SInt64)(value) << ((shift) & 0x7F))
  #endif
#endif



#if TYPE_LONGLONG || !TYPE_LONGDOUBLE_IS_DOUBLE
/*
 *  SInt64ToLongDouble()
 *  
 *  Discussion:
 *    Converts SInt64 to long double.  Note all SInt64s fit exactly
 *    into long doubles, thus, the binary -> decimal conversion
 *    routines in fp.h can be used to achieve SInt64 -> long double ->
 *    decimal conversions. Note: The function implementation assumes
 *    long double is a 128-bit floating point on PowerPC and 80-bit
 *    type on 68K
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         not available
 */
EXTERN_API_C( long double )
SInt64ToLongDouble(SInt64 value);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline long double SInt64ToLongDouble(SInt64 value) { return (long double)(value); }
  #else
    #define SInt64ToLongDouble(value) ((long double)(value))
  #endif
#endif


/*
 *  LongDoubleToSInt64()
 *  
 *  Discussion:
 *    Converts a long double to a SInt64.  Any decimal string that fits
 *    into a SInt64 can be converted exactly into a long double, using
 *    the conversion routines found in fp.h.  Then this routine can be
 *    used to complete the conversion to SInt64. Note: The function
 *    implementation assumes long double is a 128-bit floating point on
 *    PowerPC and 80-bit type on 68K
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         not available
 */
EXTERN_API_C( SInt64 )
LongDoubleToSInt64(long double value);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline SInt64 LongDoubleToSInt64(long double value) { return (SInt64)(value); }
  #else
    #define LongDoubleToSInt64(value) ((SInt64)(value))
  #endif
#endif


#endif  /* TYPE_LONGLONG || !TYPE_LONGDOUBLE_IS_DOUBLE */


/*
 *  U64Max()
 *  
 *  Discussion:
 *    Returns largest possible UInt64 value
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( UInt64 )
U64Max(void);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline UInt64 U64Max(void) { return 0xffffffffffffffffULL; }
  #else
    #define U64Max() (0xffffffffffffffffULL)
  #endif
#endif


#if defined(__MWERKS__) && (__MWERKS__ < 0x1800) && defined(U64Max)
/* older Metrowerks compilers errored on LL suffix */
 #undef U64Max
 #define U64Max() 0xffffffffffffffff
#endif
/*
 *  U64Add()
 *  
 *  Discussion:
 *    Adds two unsigned integers, producing an integer result.  If an
 *    overflow occurs the result is congruent mod (2^64) as if the
 *    operands and result were unsigned.  No overflow is signaled.
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( UInt64 )
U64Add(
  UInt64   left,
  UInt64   right);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline UInt64 U64Add(UInt64 left, UInt64 right) { return (UInt64)(left) + (UInt64)(right); }
  #else
    #define U64Add(left, right) ((UInt64)(left) + (UInt64)(right))
  #endif
#endif


/*
 *  U64Subtract()
 *  
 *  Discussion:
 *    Subtracts two unsigned integers, producing an integer result.  If
 *    an overflow occurs the result is congruent mod (2^64) as if the
 *    operands and result were unsigned.  No overflow is signaled.
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( UInt64 )
U64Subtract(
  UInt64   left,
  UInt64   right);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline UInt64 U64Subtract(UInt64 left, UInt64 right) { return (UInt64)(left) - (UInt64)(right); }
  #else
    #define U64Subtract(left, right) ((UInt64)(left) - (UInt64)(right))
  #endif
#endif



/*
 *  U64Multiply()
 *  
 *  Discussion:
 *    Multiplies two unsigned numbers, producing a signed result. 
 *    Overflow is ignored and the low-order part of the product is
 *    returned.  The sign of the result is not guaranteed to be correct
 *    if the magnitude of the product is not representable.
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( UInt64 )
U64Multiply(
  UInt64   left,
  UInt64   right);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline UInt64 U64Multiply(UInt64 left, UInt64 right) { return (UInt64)(left) * (UInt64)(right); }
  #else
    #define U64Multiply(left, right) ((UInt64)(left) * (UInt64)(right))
  #endif
#endif



#if CALL_NOT_IN_CARBON
/*
 *  U64Mod()
 *  
 *  Discussion:
 *    Returns the remainder of divide of dividend by divisor.  The sign
 *    of the remainder is the same as the sign of the dividend (i.e.,
 *    it takes the absolute values of the operands, does the division,
 *    then fixes the sign of the quotient and remainder).
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( UInt64 )
U64Mod(
  UInt64   dividend,
  UInt64   divisor);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline UInt64 U64Mod(UInt64 dividend, UInt64 divisor) { return (UInt64)(dividend) % (UInt64)(divisor); }
  #else
    #define U64Mod(dividend, divisor) ((UInt64)(dividend) % (UInt64)(divisor))
  #endif
#endif



#endif  /* CALL_NOT_IN_CARBON */

/*
 *  U64Divide()
 *  
 *  Discussion:
 *    Divides dividend by divisor, returning the quotient.  The
 *    remainder is returned in *remainder if remainder (the pointer) is
 *    non-NULL. The sign of the remainder is the same as the sign of
 *    the dividend (i.e. it takes the absolute values of the operands,
 *    does the division, then fixes the sign of the quotient and
 *    remainder).  If the divisor is zero, then U64Max() will be
 *    returned (or U64Min() if the dividend is negative), and the
 *    remainder will be the dividend; no error is reported.
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( UInt64 )
U64Divide(
  UInt64    dividend,
  UInt64    divisor,
  UInt64 *  remainder);      /* can be NULL */
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline UInt64 U64Divide(UInt64 dividend, UInt64 divisor, UInt64 *remainder) { return ((remainder) ? (*((UInt64*)(remainder)) = ((UInt64)(dividend) % (UInt64)(divisor))) : 0), ((UInt64)(dividend) / (UInt64)(divisor)); }
  #else
    #define U64Divide(dividend, divisor, remainder) (((remainder) ? (*((UInt64*)(remainder)) = ((UInt64)(dividend) % (UInt64)(divisor))) : 0), ((UInt64)(dividend) / (UInt64)(divisor)))
  #endif
#endif



#ifdef __cplusplus
  inline UInt64 U64Div(UInt64 dividend, UInt64 divisor) { return U64Divide((dividend), (divisor), NULL); }
#else
  #define U64Div(dividend, divisor) (U64Divide((dividend), (divisor), NULL))
#endif

/*
 *  U64Set()
 *  
 *  Discussion:
 *    Given an SInt32, returns an UInt64 with the same value.  Use this
 *    routine instead of coding 64-bit constants (at least when the
 *    constant will fit in an SInt32).
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( UInt64 )
U64Set(SInt32 value);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline UInt64 U64Set(SInt32 value) { return (UInt64)(value); }
  #else
    #define U64Set(value) ((UInt64)(value))
  #endif
#endif



/*
 *  U64SetU()
 *  
 *  Discussion:
 *    Given a UInt32, returns a UInt64 with the same value.
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( UInt64 )
U64SetU(UInt32 value);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline UInt64 U64SetU(UInt32 value) { return (UInt64)(value); }
  #else
    #define U64SetU(value) ((UInt64)(value))
  #endif
#endif


/*
 *  U32SetU()
 *  
 *  Discussion:
 *    Given an UInt64, returns an UInt32 by discarding the high-order
 *    32 bits.
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( UInt32 )
U32SetU(UInt64 value);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline UInt32 U32SetU(UInt64 value) { return (UInt32)(value); }
  #else
    #define U32SetU(value) ((UInt32)(value))
  #endif
#endif



/*
 *  U64And()
 *  
 *  Discussion:
 *    Returns one if left and right are non-zero, otherwise returns zero
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( Boolean )
U64And(
  UInt64   left,
  UInt64   right);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline Boolean U64And(UInt64 left, UInt64 right) { return (UInt64)(left) && (UInt64)(right); }
  #else
    #define U64And(left, right) ((UInt64)(left) && (UInt64)(right))
  #endif
#endif



/*
 *  U64Or()
 *  
 *  Discussion:
 *    Returns one if left or right are non-zero, otherwise returns zero
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( Boolean )
U64Or(
  UInt64   left,
  UInt64   right);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline Boolean U64Or(UInt64 left, UInt64 right) { return (UInt64)(left) || (UInt64)(right); }
  #else
    #define U64Or(left, right) ((UInt64)(left) || (UInt64)(right))
  #endif
#endif



/*
 *  U64Eor()
 *  
 *  Discussion:
 *    Returns one if left xor right are non-zero, otherwise returns zero
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( Boolean )
U64Eor(
  UInt64   left,
  UInt64   right);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline Boolean U64Eor(UInt64 left, UInt64 right) { return (Boolean)(((UInt64)(left) ? 1 : 0) ^ ((UInt64)(right) ? 1 : 0)); }
  #else
    #define U64Eor(left, right) ((Boolean)(((UInt64)(left) ? 1 : 0) ^ ((UInt64)(right) ? 1 : 0)))
  #endif
#endif



/*
 *  U64Not()
 *  
 *  Discussion:
 *    Returns one if value is non-zero, otherwisze returns zero.
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( Boolean )
U64Not(UInt64 value);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline Boolean U64Not(UInt64 value) { return !((UInt64)(value)); }
  #else
    #define U64Not(value) (!((UInt64)(value)))
  #endif
#endif



/*
 *  U64Compare()
 *  
 *  Discussion:
 *    Given two unsigned numbers, left and right, returns an SInt32
 *    that compares with zero the same way left compares with right. 
 *    If you wanted to perform a comparison on 64-bit integers of the
 *    form:
 *    operand_1 <operation> operand_2
 *    then you could use an expression of the form:
 *     xxxU64Compare(operand_1,operand_2) <operation> 0
 *    to test for the same condition. CAUTION: DO NOT depend on the
 *    exact value returned by this routine. Only the sign (i.e.
 *    positive, zero, or negative) of the result is guaranteed.
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( SInt32 )
U64Compare(
  UInt64   left,
  UInt64   right);


/*
 *  U64BitwiseAnd()
 *  
 *  Discussion:
 *    bitwise AND
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( UInt64 )
U64BitwiseAnd(
  UInt64   left,
  UInt64   right);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline UInt64 U64BitwiseAnd(UInt64 left, UInt64 right) { return (UInt64)(left) & (UInt64)(right); }
  #else
    #define U64BitwiseAnd(left, right) ((UInt64)(left) & (UInt64)(right))
  #endif
#endif



/*
 *  U64BitwiseOr()
 *  
 *  Discussion:
 *    bitwise OR
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( UInt64 )
U64BitwiseOr(
  UInt64   left,
  UInt64   right);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline UInt64 U64BitwiseOr(UInt64 left, UInt64 right) { return (UInt64)(left) | (UInt64)(right); }
  #else
    #define U64BitwiseOr(left, right) ((UInt64)(left) | (UInt64)(right))
  #endif
#endif



/*
 *  U64BitwiseEor()
 *  
 *  Discussion:
 *    bitwise XOR
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( UInt64 )
U64BitwiseEor(
  UInt64   left,
  UInt64   right);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline UInt64 U64BitwiseEor(UInt64 left, UInt64 right) { return (UInt64)(left) ^ (UInt64)(right); }
  #else
    #define U64BitwiseEor(left, right) ((UInt64)(left) ^ (UInt64)(right))
  #endif
#endif



/*
 *  U64BitwiseNot()
 *  
 *  Discussion:
 *    bitwise negate
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( UInt64 )
U64BitwiseNot(UInt64 value);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline UInt64 U64BitwiseNot(UInt64 value) { return ~((UInt64)(value)); }
  #else
    #define U64BitwiseNot(value) (~((UInt64)(value)))
  #endif
#endif



/*
 *  U64ShiftRight()
 *  
 *  Discussion:
 *    Arithmetic shift of value by the lower 7 bits of the shift.
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( UInt64 )
U64ShiftRight(
  UInt64   value,
  UInt32   shift);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline UInt64 U64ShiftRight(UInt64 value, UInt32 shift) { return (UInt64)(value) >> ((shift) & 0x7F); }
  #else
    #define U64ShiftRight(value, shift) ((UInt64)(value) >> ((shift) & 0x7F))
  #endif
#endif



/*
 *  U64ShiftLeft()
 *  
 *  Discussion:
 *    Logical shift of value by the lower 7 bits of the shift.
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( UInt64 )
U64ShiftLeft(
  UInt64   value,
  UInt32   shift);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline UInt64 U64ShiftLeft(UInt64 value, UInt32 shift) { return (UInt64)(value) << ((shift) & 0x7F); }
  #else
    #define U64ShiftLeft(value, shift) ((UInt64)(value) << ((shift) & 0x7F))
  #endif
#endif



#if TYPE_LONGLONG || !TYPE_LONGDOUBLE_IS_DOUBLE
/*
 *  UInt64ToLongDouble()
 *  
 *  Discussion:
 *    Convert an signed 64 bit integer to a long double (128-bit on
 *    PowerPC floating point)
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         not available
 */
EXTERN_API_C( long double )
UInt64ToLongDouble(UInt64 value);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline long double UInt64ToLongDouble(UInt64 value) { return (long double)(value); }
  #else
    #define UInt64ToLongDouble(value) ((long double)(value))
  #endif
#endif


/*
 *  LongDoubleToUInt64()
 *  
 *  Discussion:
 *    Convert long double (128-bit on PowerPC floating point) to a
 *    signed 64-bit integer
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         not available
 */
EXTERN_API_C( UInt64 )
LongDoubleToUInt64(long double value);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline UInt64 LongDoubleToUInt64(long double value) { return (UInt64)(value); }
  #else
    #define LongDoubleToUInt64(value) ((UInt64)(value))
  #endif
#endif


#endif  /* TYPE_LONGLONG || !TYPE_LONGDOUBLE_IS_DOUBLE */


/*
 *  UInt64ToSInt64()
 *  
 *  Discussion:
 *    converts UInt64 -> SInt64
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( SInt64 )
UInt64ToSInt64(UInt64 value);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline SInt64 UInt64ToSInt64(UInt64 value) { return (SInt64)(value); }
  #else
    #define UInt64ToSInt64(value) ((SInt64)(value))
  #endif
#endif



/*
 *  SInt64ToUInt64()
 *  
 *  Discussion:
 *    converts SInt64 -> UInt64
 *  
 *  Availability:
 *    Non-Carbon CFM:   available as macro/inline
 *    CarbonLib:        in CarbonLib 1.0 and later
 *    Mac OS X:         in version 10.0 or later
 */
EXTERN_API_C( UInt64 )
SInt64ToUInt64(SInt64 value);
#if TYPE_LONGLONG
  #ifdef __cplusplus
    inline UInt64 SInt64ToUInt64(SInt64 value) { return (UInt64)(value); }
  #else
    #define SInt64ToUInt64(value) ((UInt64)(value))
  #endif
#endif






/* 
    Functions to convert between [Unsigned]Wide and [S|U]Int64 types.
    
    These functions are necessary if source code which uses both
    wide and SInt64 is to compile under a compiler that supports
    long long.
    
    SInt64ToWide
    
                Converts a SInt64 to a wide struct.  If SInt64 is implemented
                as a typedef of wide, the marco does nothing. If SInt64 is 
                implememnted as a long long, it casts the long long into a 
                wide struct.
    
    WideToSInt64
    
                Converts a wide struct into a SInt64.  If SInt64 is implemented
                as a typedef of wide, the marco does nothing. If SInt64 is 
                implememnted as a long long, it reads the struct into a long long.
*/
#if TYPE_LONGLONG 
    #define SInt64ToWide(x)         (*((wide*)(&x)))
    #define WideToSInt64(x)         (*((SInt64*)(&x)))
    #define UInt64ToUnsignedWide(x) (*((UnsignedWide*)(&x)))
    #define UnsignedWideToUInt64(x) (*((UInt64*)(&x)))
#else
    #define SInt64ToWide(x)         (x)
    #define WideToSInt64(x)         (x)
    #define UInt64ToUnsignedWide(x) (x)
    #define UnsignedWideToUInt64(x) (x)
#endif




#if PRAGMA_STRUCT_ALIGN
    #pragma options align=reset
#elif PRAGMA_STRUCT_PACKPUSH
    #pragma pack(pop)
#elif PRAGMA_STRUCT_PACK
    #pragma pack()
#endif

#ifdef PRAGMA_IMPORT_OFF
#pragma import off
#elif PRAGMA_IMPORT
#pragma import reset
#endif

#ifdef __cplusplus
}
#endif

#endif /* __MATH64__ */

