A character string is a contiguous sequence of bytes in memory.  A
 character string is specified by two attributes:  the address of
 the first byte of the string and the length of the string in bytes.
 The length of the string must be in the range 1 through 65535.

 Hollerith constants are stored internally, one character per byte.

 Real and complex numbers are floating-point representations.

 COMPLEX (COMPLEX*8) data is eight contiguous bytes aligned on an
 arbitrary byte boundary.  The low-order four bytes contain REAL
 (REAL*4) data that represents the real part of the complex number.
 The high-order four bytes contain REAL data that represents the
 imaginary part of the complex number.  For information on the
 ranges of REAL data, see REAL (within the Data Constants section of
 Help).

 DOUBLE COMPLEX (COMPLEX*16) data is 16 contiguous bytes aligned on
 an arbitrary byte boundary.  The low-order bytes contain DOUBLE
 PRECISION (REAL*8) data that represents the real part of the
 complex number.  The high-order eight bytes contain DOUBLE
 PRECISION data that represents the imaginary part of the complex
 data.  For information on the ranges of DOUBLE PRECISION data, see
 DOUBLE_PRECISION (within the Data Constants section of Help).

 The integer data types have the following ranges:

   BYTE         Same range as INTEGER*1

   INTEGER*1    Signed integers: -128 to 127 (-2**7 to 2**7-1)
   (1 byte)     Unsigned integers: 0 to 255 (2**8-1)
   
   INTEGER*2    Signed integers: -32768 to 32767 
   (2 bytes)                     (-2**15 to 2**15-1)
                Unsigned integers: 0 to 65535 (2**16-1)

   INTEGER*4    Signed integers: -2147483648 to 2147483647 
   (4 bytes)                          (-2**31 to 2**31-1)
                NOTE: On RISC processors, the value of 
                an integer constant must be within this range.

   INTEGER*8    Signed integers: -9223372036854775808 to 
   (AXP only)      9223372036854775807 (-2**63 to 2**63-1)
   (8 bytes)
                NOTE: On Alpha AXP processors, the value of an 
                integer constant must be within this range.

 INTEGER*2, INTEGER*4, and INTEGER*8 values are stored in two's
 complement form.

 Note that logical data type ranges correspond to their comparable
 integer data type ranges.  For example, the LOGICAL*2 range is the
 same as the INTEGER*2 range.

 The value of an integer constant is normally INTEGER*2, INTEGER*4,
 or INTEGER*8 (AXP only).  If a value is within INTEGER*2 range, it
 is treated as an INTEGER*2 value; if a value is outside INTEGER*2
 range, but within INTEGER*4 range, it is treated as an INTEGER*4
 value, and so forth.

 Logical values start on an arbitrary byte boundary and are stored
 in one, two, or four contiguous bytes.  The low-order bit (bit 0)
 determines the value.  If bit 0 is set, the value is .TRUE.; if bit
 0 is clear, the value is .FALSE.  The remaining bits are undefined.

 When a logical value is stored in memory, all of its bits are
 stored.  For example, consider the following:

    LOGICAL*4 L1, L2, L3
    L1 = L2 .AND. L3

 This example does a full 32-bit AND of L2 and L3, and stores all 32
 resulting bits in L1.

 Real and complex numbers are floating-point representations.

 The exponent for REAL (REAL*4) (S_floating) and DOUBLE PRECISION
 (REAL*8) (T_floating) formats is stored in binary excess 128
 notation.  Binary exponents from -127 to 127 are represented by the
 binary equivalents of 1 through 255.

 For floating-point format, fractions are represented in
 sign-magnitude notation, with the binary radix point to the left of
 the most significant bit.  Fractions are assumed to be normalized,
 and therefore the most significant bit is not stored.  This bit is
 assumed to be 1 unless the exponent is 0.  in which case the value
 represented is either zero or is a reserved operand.

 REAL (REAL*4) (S_floating) numbers occupy four contiguous bytes and
 the precision is approximately one part in 2**23, that is,
 typically 7 decimal digits.

 DOUBLE PRECISION (REAL*8) (T_floating) numbers occupy eight
 contiguous bytes and the precision is approximately one part in
 2**55, that is, typically 16 decimal digits.

 For more information on real data type ranges, see DATA CONSTANTS
 REAL and DATA CONSTANTS DOUBLE_PRECISION in this online Help file.