code: func (enc *Encoder) encodeFixedArray(v reflect.Value, ignoreOpaque bool) (int, error) {
  	// Treat [#]byte (byte is alias for uint8) as opaque data unless ignored.
  	if !ignoreOpaque && v.Type().Elem().Kind() == reflect.Uint8 {
  		// Create a slice of the underlying array for better efficiency
  		// when possible.  Can't create a slice of an unaddressable
  		// value.
  		if v.CanAddr() {
  			return enc.EncodeFixedOpaque(v.Slice(0, v.Len()).Bytes())
  		}
  
  		// When the underlying array isn't addressable fall back to
  		// copying the array into a new slice.  This is rather ugly, but
  		// the inability to create a constant slice from an
  		// unaddressable array is a limitation of Go.
  		slice := make([]byte, v.Len(), v.Len())
  		reflect.Copy(reflect.ValueOf(slice), v)
  		return enc.EncodeFixedOpaque(slice)
  	}
  
  	// Encode each array element.
  	var n int
  	for i := 0; i < v.Len(); i++ {
  		n2, err := enc.encode(v.Index(i))
  		n += n2
  		if err != nil {
  			return n, err
  		}
  	}
  
  	return n, nil
  }
docs: // encodeFixedArray writes the XDR encoded representation of each element
  // in the passed array represented by the reflection value to the encapsulated
  // writer and returns the number of bytes written.  The ignoreOpaque flag
  // controls whether or not uint8 (byte) elements should be encoded individually
  // or as a fixed sequence of opaque data.
  //
  // A MarshalError is returned if any issues are encountered while encoding
  // the array elements.
  //
  // Reference:
  // 	RFC Section 4.12 - Fixed-Length Array
  // 	Individually XDR encoded array elements