code: func (enc *Encoder) EncodeFixedOpaque(v []byte) (int, error) {
  	l := len(v)
  	pad := (4 - (l % 4)) % 4
  
  	// Write the actual bytes.
  	n, err := enc.w.Write(v)
  	if err != nil {
  		msg := fmt.Sprintf(errIOEncode, err.Error(), len(v))
  		err := marshalError("EncodeFixedOpaque", ErrIO, msg, v[:n], err)
  		return n, err
  	}
  
  	// Write any padding if needed.
  	if pad > 0 {
  		b := make([]byte, pad)
  		n2, err := enc.w.Write(b)
  		n += n2
  		if err != nil {
  			written := make([]byte, l+n2)
  			copy(written, v)
  			copy(written[l:], b[:n2])
  			msg := fmt.Sprintf(errIOEncode, err.Error(), l+pad)
  			err := marshalError("EncodeFixedOpaque", ErrIO, msg,
  				written, err)
  			return n, err
  		}
  	}
  
  	return n, nil
  }
docs: // RFC Section 4.8 -  Quadruple-Precision Floating Point
  // 128-bit quadruple-precision floating point
  // Not Implemented
  // EncodeFixedOpaque treats the passed byte slice as opaque data of a fixed
  // size and writes the XDR encoded representation of it  to the encapsulated
  // writer.  It returns the number of bytes written.
  //
  // A MarshalError with an error code of ErrIO is returned if writing the data
  // fails.
  //
  // Reference:
  // 	RFC Section 4.9 - Fixed-Length Opaque Data
  // 	Fixed-length uninterpreted data zero-padded to a multiple of four