Next: , Previous: , Up: Top   [Index]


Appendix B Summary of Fortran 77 Interface

  1. Library APIs
  2. Error report APIs
  3. File APIs
  4. Entering/exiting independent data mode APIs
  5. Nonblocking I/O control APIs
  6. File inquiry APIs
  7. Dimension APIs
  8. Attribute inquiry APIs
  9. Attribute put/get APIs
  10. General variable APIs
  11. Blocking put/get entire variable APIs
  12. Blocking put/get a single variable element APIs
  13. Blocking put/get variable subarray APIs
  14. Blocking put/get variable strided subarray APIs
  15. Blocking put/get variable mapped and strided APIs
  16. Nonblocking iput/iget the entire variable APIs
  17. Nonblocking iput/iget a single variable element APIs
  18. Nonblocking iput/iget a variable subarray APIs
  19. Nonblocking iput/iget a variable strided subarray APIs
  20. Nonblocking iput/iget a variable mapped and strided subarray APIs
  21. Nonblocking buffered put APIs
  22. Blocking put/get an array of values using filetype
  23. Blocking and nonblocking put/get a list of subarrays

Library APIs

character(LEN=80) FUNCTION nfmpi_inq_libvers()

Error report APIs

character(LEN=80) FUNCTION nfmpi_strerror(ncerr)
                  INTEGER, INTENT(IN) :: ncerr

logical           FUNCTION nfmpi_issyserr(ncerr)
                  INTEGER, INTENT(IN) :: ncerr

character(LEN=80) FUNCTION nfmpi_strerrno(ncerr)
                  INTEGER, INTENT(IN) :: ncerr

File APIs

INTEGER FUNCTION nfmpi_create(mpi_comm, path, cmode, mpi_info, ncid)
                 INTEGER,                       INTENT(IN)  :: mpi_comm
                 CHARACTER(len=*),              INTENT(IN)  :: path
                 INTEGER,                       INTENT(IN)  :: cmode
                 INTEGER,                       INTENT(IN)  :: mpi_info
                 INTEGER,                       INTENT(OUT) :: ncid

INTEGER FUNCTION nfmpi_open(mpi_comm, path, mode, mpi_info, ncid)
                 INTEGER,                       INTENT(IN)  :: mpi_comm
                 CHARACTER(len=*),              INTENT(IN)  :: path
                 INTEGER,                       INTENT(IN)  :: mode
                 INTEGER,                       INTENT(IN)  :: mpi_info
                 INTEGER,                       INTENT(OUT) :: ncid

INTEGER FUNCTION nfmpi_enddef(ncid)
                 INTEGER,                       INTENT(IN)  :: ncid

INTEGER FUNCTION nfmpi__enddef(ncid, h_minfree, v_align, v_minfree, r_align)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: h_minfree
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: v_align
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: v_minfree
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: r_align

INTEGER FUNCTION nfmpi_redef(ncid)
                 INTEGER,                       INTENT(IN)  :: ncid

INTEGER FUNCTION nfmpi_flush(ncid)
                 INTEGER,                       INTENT(IN)  :: ncid

INTEGER FUNCTION nfmpi_sync(ncid)
                 INTEGER,                       INTENT(IN)  :: ncid

INTEGER FUNCTION nfmpi_sync_numrecs(ncid)
                 INTEGER,                       INTENT(IN)  :: ncid

INTEGER FUNCTION nfmpi_close(ncid)
                 INTEGER,                       INTENT(IN)  :: ncid

INTEGER FUNCTION nfmpi_set_fill(ncid, fillmode, old_mode)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: fillmode
                 INTEGER,                       INTENT(OUT) :: old_mode

INTEGER FUNCTION nfmpi_set_default_format(new_fmt, old_fmt)
                 INTEGER,                       INTENT(IN)  :: new_fmt
                 INTEGER,                       INTENT(OUT) :: old_fmt

INTEGER FUNCTION nfmpi_abort(ncid)
                 INTEGER,                       INTENT(IN)  :: ncid

INTEGER FUNCTION nfmpi_delete(path, mpi_info)
                 CHARACTER(len=*),              INTENT(IN)  :: path
                 INTEGER,                       INTENT(IN)  :: mpi_info

Entering/exiting independent data mode APIs

INTEGER FUNCTION nfmpi_begin_indep_data(ncid)
                 INTEGER,                       INTENT(IN)  :: ncid

INTEGER FUNCTION nfmpi_end_indep_data(ncid)
                 INTEGER,                       INTENT(IN)  :: ncid

Nonblocking I/O control APIs

INTEGER FUNCTION nfmpi_wait(ncid, count, req, status)
                 INTEGER,                       INTENT(IN)   :: ncid
                 INTEGER,                       INTENT(IN)   :: count
                 INTEGER,                       INTENT(INOUT):: req(count)
                 INTEGER,                       INTENT(OUT)  :: status(count)

INTEGER FUNCTION nfmpi_wait_all(ncid, count, req, status)
                 INTEGER,                       INTENT(IN)   :: ncid
                 INTEGER,                       INTENT(IN)   :: count
                 INTEGER,                       INTENT(INOUT):: req(count)
                 INTEGER,                       INTENT(OUT)  :: status(count)

INTEGER FUNCTION nfmpi_cancel(ncid, count, req, status)
                 INTEGER,                       INTENT(IN)   :: ncid
                 INTEGER,                       INTENT(IN)   :: count
                 INTEGER,                       INTENT(INOUT):: req(count)
                 INTEGER,                       INTENT(OUT)  :: status(count)

File inquiry APIs

INTEGER FUNCTION nfmpi_inq(ncid, ndims, nvars, ngatts, unlimdimid)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(OUT) :: ndims
                 INTEGER,                       INTENT(OUT) :: nvars
                 INTEGER,                       INTENT(OUT) :: ngatts
                 INTEGER,                       INTENT(OUT) :: unlimdimid

INTEGER FUNCTION nfmpi_inq_ndims(ncid, ndims)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(OUT) :: ndims

INTEGER FUNCTION nfmpi_inq_nvars(ncid, nvars)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(OUT) :: nvars

INTEGER FUNCTION nfmpi_inq_natts(ncid, ngatts)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(OUT) :: ngatts

INTEGER FUNCTION nfmpi_inq_unlimdim(ncid, unlimdimid)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(OUT) :: unlimdimid

INTEGER FUNCTION nfmpi_inq_format(ncid, fmt)
                 INTEGER,                       INTENT(IN)   :: ncid
                 INTEGER,                       INTENT(OUT)  :: fmt

INTEGER FUNCTION nfmpi_inq_file_format(path, fmt)
                 CHARACTER(len=*),              INTENT(IN)  :: path
                 INTEGER,                       INTENT(OUT)  :: fmt

INTEGER FUNCTION nfmpi_inq_default_format(default_fmt)
                 INTEGER,                       INTENT(OUT) :: default_fmt

INTEGER FUNCTION nfmpi_inq_header_size(ncid, size)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(OUT) :: size

INTEGER FUNCTION nfmpi_inq_header_extent(ncid, extent)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(OUT) :: extent

INTEGER FUNCTION nfmpi_inq_files_opened(nfiles, ncids)
                 INTEGER,                       INTENT(OUT) :: nfiles
                 INTEGER,                       INTENT(OUT) :: ncids(*)

INTEGER FUNCTION nfmpi_inq_path(ncid, pathlen, path)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(OUT) :: pathlen
                 CHARACTER(len=*),              INTENT(OUT) :: path

INTEGER FUNCTION nfmpi_inq_num_rec_vars(ncid, nvars)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(OUT) :: nvars

INTEGER FUNCTION nfmpi_inq_num_fix_vars(ncid, nvars)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(OUT) :: nvars

INTEGER FUNCTION nfmpi_inq_recsize(ncid, recsize)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(OUT) :: recsize

INTEGER FUNCTION nfmpi_inq_file_info(ncid, mpi_info)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(OUT) :: mpi_info

INTEGER FUNCTION nfmpi_get_file_info(ncid, mpi_info)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(OUT) :: mpi_info

INTEGER FUNCTION nfmpi_inq_striping(ncid, striping_size, striping_count)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(OUT) :: striping_size
                 INTEGER,                       INTENT(OUT) :: striping_count

INTEGER FUNCTION nfmpi_inq_put_size(ncid, size)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(OUT) :: size

INTEGER FUNCTION nfmpi_inq_get_size(ncid, size)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(OUT) :: size

INTEGER FUNCTION nfmpi_inq_nreqs(ncid, nreqs)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(OUT) :: nreqs

INTEGER FUNCTION nfmpi_inq_malloc_size(size)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(OUT) :: size

INTEGER FUNCTION nfmpi_inq_malloc_max_size(size)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(OUT) :: size

INTEGER FUNCTION nfmpi_inq_malloc_list()

Dimension APIs

INTEGER FUNCTION nfmpi_def_dim(ncid, name, len, dimid)
                 INTEGER,                       INTENT(IN)  :: ncid
                 CHARACTER(len=*),              INTENT(IN)  :: name
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: len
                 INTEGER,                       INTENT(OUT) :: dimid

INTEGER FUNCTION nfmpi_inq_dimid(ncid, name, dimid)
                 INTEGER,                       INTENT(IN)  :: ncid
                 CHARACTER(len=*),              INTENT(IN)  :: name
                 INTEGER,                       INTENT(OUT) :: dimid

INTEGER FUNCTION nfmpi_inq_dim(ncid, dimid, name, len)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: dimid
                 CHARACTER(len=*),              INTENT(OUT) :: name
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(OUT) :: len

INTEGER FUNCTION nfmpi_inq_dimname(ncid, dimid, name)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: dimid
                 CHARACTER(len=*),              INTENT(OUT) :: name

INTEGER FUNCTION nfmpi_inq_dimlen(ncid, dimid, len)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: dimid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(OUT) :: len

INTEGER FUNCTION nfmpi_rename_dim(ncid, dimid, name)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: dimid
                 CHARACTER(len=*),              INTENT(IN)  :: name

Attribute inquiry APIs

INTEGER FUNCTION nfmpi_inq_att(ncid, varid, name, xtype, len)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 CHARACTER(len=*),              INTENT(IN)  :: name
                 INTEGER,                       INTENT(OUT) :: xtype
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(OUT) :: len

INTEGER FUNCTION nfmpi_inq_attid(ncid, varid, name, attid)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 CHARACTER(len=*),              INTENT(IN)  :: name
                 INTEGER,                       INTENT(OUT) :: attid

INTEGER FUNCTION nfmpi_inq_atttype(ncid, varid, name, xtype)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 CHARACTER(len=*),              INTENT(IN)  :: name
                 INTEGER,                       INTENT(OUT) :: xtype

INTEGER FUNCTION nfmpi_inq_attlen(ncid, varid, name, len)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 CHARACTER(len=*),              INTENT(IN)  :: name
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(OUT) :: len

INTEGER FUNCTION nfmpi_inq_attname(ncid, varid, attid, name)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: attid
                 CHARACTER(len=*),              INTENT(OUT) :: name

INTEGER FUNCTION nfmpi_copy_att(ncid_in, varid_in, name, ncid_out, varid_out)
                 INTEGER,                       INTENT(IN)  :: ncid_in
                 INTEGER,                       INTENT(IN)  :: varid_in
                 CHARACTER(len=*),              INTENT(IN)  :: name
                 INTEGER,                       INTENT(IN)  :: ncid_out
                 INTEGER,                       INTENT(IN)  :: varid_out

INTEGER FUNCTION nfmpi_rename_att(ncid, varid, curname, newname)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 CHARACTER(len=*),              INTENT(IN)  :: curname
                 CHARACTER(len=*),              INTENT(IN)  :: newname

INTEGER FUNCTION nfmpi_del_att(ncid, varid, name)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 CHARACTER(len=*),              INTENT(IN)  :: name

Attribute put/get APIs

INTEGER FUNCTION nfmpi_put_att_text(ncid, varid, name, len, text)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 CHARACTER(len=*),              INTENT(IN)  :: name
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: len
                 CHARACTER(len=*),              INTENT(IN)  :: text

INTEGER FUNCTION nfmpi_get_att_text(ncid, varid, name, text)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 CHARACTER(len=*),              INTENT(IN)  :: name
                 CHARACTER(len=*),              INTENT(OUT) :: text

INTEGER FUNCTION nfmpi_put_att_int1(ncid, varid, name, xtype, len, i1vals)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 CHARACTER(len=*),              INTENT(IN)  :: name
                 INTEGER,                       INTENT(IN)  :: xtype
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: len
                 INTEGER(KIND=OneByteInt),      INTENT(IN)  :: i1vals(*)

INTEGER FUNCTION nfmpi_get_att_int1(ncid, varid, name, i1vals)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 CHARACTER(len=*),              INTENT(IN)  :: name
                 INTEGER(KIND=OneByteInt),      INTENT(OUT) :: i1vals(*)

INTEGER FUNCTION nfmpi_put_att_int2(ncid, varid, name, xtype, len, i2vals)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 CHARACTER(len=*),              INTENT(IN)  :: name
                 INTEGER,                       INTENT(IN)  :: xtype
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: len
                 INTEGER(KIND=TwoByteInt),      INTENT(IN)  :: i2vals(*)

INTEGER FUNCTION nfmpi_get_att_int2(ncid, varid, name, i2vals)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 CHARACTER(len=*),              INTENT(IN)  :: name
                 INTEGER(KIND=TwoByteInt),      INTENT(OUT) :: i2vals(*)

INTEGER FUNCTION nfmpi_put_att_int(ncid, varid, name, xtype, len, IVALS)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 CHARACTER(len=*),              INTENT(IN)  :: name
                 INTEGER,                       INTENT(IN)  :: xtype
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: len
                 INTEGER,                       INTENT(IN)  :: ivals(*)

INTEGER FUNCTION nfmpi_get_att_int(ncid, varid, name, IVALS)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 CHARACTER(len=*),              INTENT(IN)  :: name
                 INTEGER,                       INTENT(OUT) :: ivals(*)

INTEGER FUNCTION nfmpi_put_att_real(ncid, varid, name, xtype, len, RVALS)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 CHARACTER(len=*),              INTENT(IN)  :: name
                 INTEGER,                       INTENT(IN)  :: xtype
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: len
                 REAL,                          INTENT(IN)  :: rvals(*)

INTEGER FUNCTION nfmpi_get_att_real(ncid, varid, name, rvals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 CHARACTER(len=*),              INTENT(IN)  :: name
                 REAL,                          INTENT(OUT) :: rvals(*)

INTEGER FUNCTION nfmpi_put_att_double(ncid, varid, name, xtype, len, dvals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 CHARACTER(len=*),              INTENT(IN)  :: name
                 INTEGER,                       INTENT(IN)  :: xtype
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: len
                 DOUBLE PRECISION,              INTENT(IN)  :: dvals(*)

INTEGER FUNCTION nfmpi_get_att_double(ncid, varid, name, dvals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 CHARACTER(len=*),              INTENT(IN)  :: name
                 DOUBLE PRECISION,              INTENT(OUT) :: dvals(*)

INTEGER FUNCTION nfmpi_put_att_int8(ncid, varid, name, xtype, len, i8vals)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 CHARACTER(len=*),              INTENT(IN)  :: name
                 INTEGER,                       INTENT(IN)  :: xtype
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: len
                 INTEGER(KIND=EightByteInt),    INTENT(IN)  :: i8vals(*)

INTEGER FUNCTION nfmpi_get_att_int8(ncid, varid, name, i8vals)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 CHARACTER(len=*),              INTENT(IN)  :: name
                 INTEGER(KIND=EightByteInt),    INTENT(OUT) :: i8vals(*)

General variable APIs

INTEGER FUNCTION nfmpi_def_var(ncid, name, datatype, ndims, dimids, varid)
                 INTEGER,                       INTENT(IN)  :: ncid
                 CHARACTER(len=*),              INTENT(IN)  :: name
                 INTEGER,                       INTENT(IN)  :: datatype
                 INTEGER,                       INTENT(IN)  :: ndims
                 INTEGER,                       INTENT(IN)  :: dimids(ndims)
                 INTEGER,                       INTENT(OUT) :: varid

INTEGER FUNCTION nfmpi_inq_var(ncid, varid, name, datatype, ndims, dimids, natts)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 CHARACTER(len=*),              INTENT(OUT) :: name
                 INTEGER,                       INTENT(OUT) :: datatype
                 INTEGER,                       INTENT(OUT) :: ndims
                 INTEGER,                       INTENT(OUT) :: dimids(*)
                 INTEGER,                       INTENT(OUT) :: natts

INTEGER FUNCTION nfmpi_inq_varid(ncid, name, varid)
                 INTEGER,                       INTENT(IN)  :: ncid
                 CHARACTER(len=*),              INTENT(IN)  :: name
                 INTEGER,                       INTENT(OUT) :: varid

INTEGER FUNCTION nfmpi_inq_varname(ncid, varid, name)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 CHARACTER(len=*),              INTENT(OUT) :: name

INTEGER FUNCTION nfmpi_inq_vartype(ncid, varid, xtype)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(OUT) :: xtype

INTEGER FUNCTION nfmpi_inq_varndims(ncid, varid, ndims)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(OUT) :: ndims

INTEGER FUNCTION nfmpi_inq_vardimid(ncid, varid, dimids)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(OUT) :: dimids(*)

INTEGER FUNCTION nfmpi_inq_varnatts(ncid, varid, natts)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(OUT) :: natts

INTEGER FUNCTION nfmpi_inq_varoffset(ncid, varid, offset)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(OUT) :: offset

INTEGER FUNCTION nfmpi_rename_var(ncid, varid, name)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 CHARACTER(len=*),              INTENT(IN)  :: name

INTEGER FUNCTION nfmpi_def_var_fill(ncid, varid, no_fill, fill_value)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: no_fill
                 <any valid type>,              INTENT(IN)  :: fill_value

INTEGER FUNCTION nfmpi_inq_var_fill(ncid, varid, no_fill, fill_value)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(OUT) :: no_fill
                 <any valid type>,              INTENT(OUT) :: fill_value

INTEGER FUNCTION nfmpi_fill_var_rec(ncid, varid, recno)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: recno

Blocking put/get entire variable APIs

INTEGER FUNCTION nfmpi_put_var(ncid, varid, buf, bufcount, datatype)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 <any valid type>,              INTENT(IN)  :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: datatype

INTEGER FUNCTION nfmpi_get_var(ncid, varid, buf, bufcount, datatype)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 <any valid type>,              INTENT(OUT) :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: datatype

INTEGER FUNCTION nfmpi_get_var_all (ncid, varid, buf, bufcount, datatype)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 <any valid type>,              INTENT(OUT) :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: datatype

INTEGER FUNCTION nfmpi_put_var_text(ncid, varid, text)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 CHARACTER(len=*),              INTENT(IN)  :: text

INTEGER FUNCTION nfmpi_get_var_text(ncid, varid, text)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 CHARACTER(len=*),              INTENT(OUT) :: text

INTEGER FUNCTION nfmpi_get_var_text_all(ncid, varid, text)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 CHARACTER(len=*),              INTENT(OUT) :: text

INTEGER FUNCTION nfmpi_put_var_int1(ncid, varid, i1vals)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=OneByteInt),      INTENT(IN)  :: i1vals(*)

INTEGER FUNCTION nfmpi_get_var_int1(ncid, varid, i1vals)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=OneByteInt),      INTENT(OUT) :: i1vals(*)

INTEGER FUNCTION nfmpi_get_var_int1_all(ncid, varid, i1vals)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=OneByteInt),      INTENT(OUT) :: i1vals(*)

INTEGER FUNCTION nfmpi_put_var_int2(ncid, varid, i2vals)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=TwoByteInt),      INTENT(INOUT) :: i2vals(*)

INTEGER FUNCTION nfmpi_get_var_int2(ncid, varid, i2vals)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=TwoByteInt),      INTENT(OUT) :: i2vals(*)

INTEGER FUNCTION nfmpi_get_var_int2_all(ncid, varid, i2vals)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=TwoByteInt),      INTENT(OUT) :: i2vals(*)

INTEGER FUNCTION nfmpi_put_var_int(ncid, varid, ivals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(INOUT) :: ivals(*)

INTEGER FUNCTION nfmpi_get_var_int(ncid, varid, ivals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(OUT) :: ivals(*)

INTEGER FUNCTION nfmpi_get_var_int_all(ncid, varid, ivals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(OUT) :: ivals(*)

INTEGER FUNCTION nfmpi_put_var_real(ncid, varid, rvals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 REAL,                          INTENT(INOUT) :: rvals(*)

INTEGER FUNCTION nfmpi_get_var_real(ncid, varid, rvals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 REAL,                          INTENT(OUT) :: rvals(*)

INTEGER FUNCTION nfmpi_get_var_real_all(ncid, varid, rvals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 REAL,                          INTENT(OUT) :: rvals(*)

INTEGER FUNCTION nfmpi_put_var_double(ncid, varid, dvals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 DOUBLE PRECISION,              INTENT(INOUT) :: dvals(*)

INTEGER FUNCTION nfmpi_get_var_double(ncid, varid, dvals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 DOUBLE PRECISION,              INTENT(OUT) :: dvals(*)

INTEGER FUNCTION nfmpi_get_var_double_all(ncid, varid, dvals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 DOUBLE PRECISION,              INTENT(OUT) :: dvals(*)

INTEGER FUNCTION nfmpi_put_var_int8(ncid, varid, i8vals)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=EightByteInt),    INTENT(INOUT) :: i8vals(*)

INTEGER FUNCTION nfmpi_get_var_int8(ncid, varid, i8vals)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=EightByteInt),    INTENT(OUT) :: i8vals(*)

INTEGER FUNCTION nfmpi_get_var_int8_all(ncid, varid, i8vals)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=EightByteInt),    INTENT(OUT) :: i8vals(*)

Blocking put/get a single variable element APIs

INTEGER FUNCTION nfmpi_put_var1(ncid, varid, index, buf, bufcount, datatype)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 <any valid type>,              INTENT(IN)  :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: datatype

INTEGER FUNCTION nfmpi_put_var1_all(ncid, varid, index, buf, bufcount, datatype)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 <any valid type>,              INTENT(IN)  :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: datatype

INTEGER FUNCTION nfmpi_get_var1(ncid, varid, index, buf, bufcount, datatype)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 <any valid type>,              INTENT(OUT) :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: datatype

INTEGER FUNCTION nfmpi_get_var1_all(ncid, varid, index, buf, bufcount, datatype)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 <any valid type>,              INTENT(OUT) :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: datatype

INTEGER FUNCTION nfmpi_put_var1_text(ncid, varid, index, text)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 CHARACTER,                     INTENT(IN)  :: text

INTEGER FUNCTION nfmpi_put_var1_text_all(ncid, varid, index, text)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 CHARACTER,                     INTENT(IN)  :: text

INTEGER FUNCTION nfmpi_get_var1_text(ncid, varid, index, text)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 CHARACTER,                     INTENT(OUT) :: text

INTEGER FUNCTION nfmpi_get_var1_text_all(ncid, varid, index, text)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 CHARACTER,                     INTENT(OUT) :: text

INTEGER FUNCTION nfmpi_put_var1_int1(ncid, varid, index, i1val)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 INTEGER(KIND=OneByteInt),      INTENT(IN)  :: i1val

INTEGER FUNCTION nfmpi_put_var1_int1_all(ncid, varid, index, i1val)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 INTEGER(KIND=OneByteInt),      INTENT(IN)  :: i1val

INTEGER FUNCTION nfmpi_get_var1_int1(ncid, varid, index, i1val)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 INTEGER(KIND=OneByteInt),      INTENT(OUT) :: i1val

INTEGER FUNCTION nfmpi_get_var1_int1_all(ncid, varid, index, i1val)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 INTEGER(KIND=OneByteInt),      INTENT(OUT) :: i1val

INTEGER FUNCTION nfmpi_put_var1_int2(ncid, varid, index, i2val)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 INTEGER(KIND=TwoByteInt),      INTENT(INOUT) :: i2val

INTEGER FUNCTION nfmpi_put_var1_int2_all(ncid, varid, index, i2val)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 INTEGER(KIND=TwoByteInt),      INTENT(INOUT) :: i2val

INTEGER FUNCTION nfmpi_get_var1_int2(ncid, varid, index, i2val)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 INTEGER(KIND=TwoByteInt),      INTENT(OUT) :: i2val

INTEGER FUNCTION nfmpi_get_var1_int2_all(ncid, varid, index, i2val)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 INTEGER(KIND=TwoByteInt),      INTENT(OUT) :: i2val

INTEGER FUNCTION nfmpi_put_var1_int(ncid, varid, index, ival)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 INTEGER,                       INTENT(INOUT) :: ival

INTEGER FUNCTION nfmpi_put_var1_int_all(ncid, varid, index, ival)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 INTEGER,                       INTENT(INOUT) :: ival

INTEGER FUNCTION nfmpi_get_var1_int(ncid, varid, index, ival)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 INTEGER,                       INTENT(OUT) :: ival

INTEGER FUNCTION nfmpi_get_var1_int_all(ncid, varid, index, ival)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 INTEGER,                       INTENT(OUT) :: ival

INTEGER FUNCTION nfmpi_put_var1_real(ncid, varid, index, rval)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 REAL,                          INTENT(INOUT) :: rval

INTEGER FUNCTION nfmpi_put_var1_real_all(ncid, varid, index, rval)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 REAL,                          INTENT(INOUT) :: rval

INTEGER FUNCTION nfmpi_get_var1_real(ncid, varid, index, rval)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 REAL,                          INTENT(OUT) :: rval

INTEGER FUNCTION nfmpi_get_var1_real_all(ncid, varid, index, rval)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 REAL,                          INTENT(OUT) :: rval

INTEGER FUNCTION nfmpi_put_var1_double(ncid, varid, index, dval)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 DOUBLE PRECISION,              INTENT(INOUT) :: dval

INTEGER FUNCTION nfmpi_put_var1_double_all(ncid, varid, index, dval)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 DOUBLE PRECISION,              INTENT(INOUT) :: dval

INTEGER FUNCTION nfmpi_get_var1_double(ncid, varid, index, dval)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 DOUBLE PRECISION,              INTENT(OUT) :: dval

INTEGER FUNCTION nfmpi_get_var1_double_all(ncid, varid, index, dval)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 DOUBLE PRECISION,              INTENT(OUT) :: dval

INTEGER FUNCTION nfmpi_put_var1_int8(ncid, varid, index, i8val)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 INTEGER(KIND=EightByteInt),    INTENT(INOUT) :: i8val

INTEGER FUNCTION nfmpi_put_var1_int8_all(ncid, varid, index, i8val)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 INTEGER(KIND=EightByteInt),    INTENT(INOUT) :: i8val

INTEGER FUNCTION nfmpi_get_var1_int8(ncid, varid, index, i8val)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 INTEGER(KIND=EightByteInt),    INTENT(OUT) :: i8val

INTEGER FUNCTION nfmpi_get_var1_int8_all(ncid, varid, index, i8val)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 INTEGER(KIND=EightByteInt),    INTENT(OUT) :: i8val

Blocking put/get variable subarray APIs

INTEGER FUNCTION nfmpi_put_vara(ncid, varid, start, count, buf, bufcount, datatype)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 <any valid type>,              INTENT(IN)  :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: datatype

INTEGER FUNCTION nfmpi_put_vara_all(ncid, varid, start, count, buf, bufcount, datatype)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 <any valid type>,              INTENT(IN)  :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: datatype

INTEGER FUNCTION nfmpi_get_vara(ncid, varid, start, count, buf, bufcount, datatype)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 <any valid type>,              INTENT(OUT) :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: datatype

INTEGER FUNCTION nfmpi_get_vara_all (ncid, varid, start, count, buf, bufcount, datatype)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 <any valid type>,              INTENT(OUT) :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: datatype

INTEGER FUNCTION nfmpi_put_vara_text(ncid, varid, start, count, text)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 CHARACTER(len=*),              INTENT(IN)  :: text

INTEGER FUNCTION nfmpi_put_vara_text_all(ncid, varid, start, count, text)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 CHARACTER(len=*),              INTENT(IN)  :: text

INTEGER FUNCTION nfmpi_get_vara_text(ncid, varid, start, count, text)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 CHARACTER(len=*),              INTENT(OUT) :: text

INTEGER FUNCTION nfmpi_get_vara_text_all(ncid, varid, start, count, text)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 CHARACTER(len=*),              INTENT(OUT) :: text

INTEGER FUNCTION nfmpi_put_vara_int1(ncid, varid, start, count, i1vals)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=OneByteInt),      INTENT(IN)  :: i1vals(*)

INTEGER FUNCTION nfmpi_put_vara_int1_all(ncid, varid, start, count, i1vals)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=OneByteInt),      INTENT(IN)  :: i1vals(*)

INTEGER FUNCTION nfmpi_get_vara_int1(ncid, varid, start, count, i1vals)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=OneByteInt),      INTENT(OUT) :: i1vals(*)

INTEGER FUNCTION nfmpi_get_vara_int1_all(ncid, varid, start, count, i1vals)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=OneByteInt),      INTENT(OUT) :: i1vals(*)

INTEGER FUNCTION nfmpi_put_vara_int2(ncid, varid, start, count, i2vals)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=TwoByteInt),      INTENT(INOUT) :: i2vals(*)

INTEGER FUNCTION nfmpi_put_vara_int2_all(ncid, varid, start, count, i2vals)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=TwoByteInt),      INTENT(INOUT) :: i2vals(*)

INTEGER FUNCTION nfmpi_get_vara_int2(ncid, varid, start, count, i2vals)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=TwoByteInt),      INTENT(OUT) :: i2vals(*)

INTEGER FUNCTION nfmpi_get_vara_int2_all(ncid, varid, start, count, i2vals)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=TwoByteInt),      INTENT(OUT) :: i2vals(*)

INTEGER FUNCTION nfmpi_put_vara_int(ncid, varid, start, count, ivals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER,                       INTENT(INOUT) :: ivals(*)

INTEGER FUNCTION nfmpi_put_vara_int_all(ncid, varid, start, count, ivals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER,                       INTENT(INOUT) :: ivals(*)

INTEGER FUNCTION nfmpi_get_vara_int(ncid, varid, start, count, ivals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER,                       INTENT(OUT) :: ivals(*)

INTEGER FUNCTION nfmpi_get_vara_int_all(ncid, varid, start, count, ivals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER,                       INTENT(OUT) :: ivals(*)

INTEGER FUNCTION nfmpi_put_vara_real(ncid, varid, start, count, rvals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 REAL,                          INTENT(INOUT) :: rvals(*)

INTEGER FUNCTION nfmpi_put_vara_real_all(ncid, varid, start, count, rvals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 REAL,                          INTENT(INOUT) :: rvals(*)

INTEGER FUNCTION nfmpi_get_vara_real(ncid, varid, start, count, rvals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 REAL,                          INTENT(OUT) :: rvals(*)

INTEGER FUNCTION nfmpi_get_vara_real_all(ncid, varid, start, count, rvals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 REAL,                          INTENT(OUT) :: rvals(*)

INTEGER FUNCTION nfmpi_put_vara_double(ncid, varid, start, count, dvals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 DOUBLE PRECISION,              INTENT(INOUT) :: dvals(*)

INTEGER FUNCTION nfmpi_put_vara_double_all(ncid, varid, start, count, dvals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 DOUBLE PRECISION,              INTENT(INOUT) :: dvals(*)

INTEGER FUNCTION nfmpi_get_vara_double(ncid, varid, start, count, dvals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 DOUBLE PRECISION,              INTENT(OUT) :: dvals(*)

INTEGER FUNCTION nfmpi_get_vara_double_all(ncid, varid, start, count, dvals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 DOUBLE PRECISION,              INTENT(OUT) :: dvals(*)

INTEGER FUNCTION nfmpi_put_vara_int8(ncid, varid, start, count, i8vals)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=EightByteInt),    INTENT(INOUT) :: i8vals(*)

INTEGER FUNCTION nfmpi_put_vara_int8_all(ncid, varid, start, count, i8vals)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=EightByteInt),    INTENT(INOUT) :: i8vals(*)

INTEGER FUNCTION nfmpi_get_vara_int8(ncid, varid, start, count, i8vals)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=EightByteInt),    INTENT(OUT) :: i8vals(*)

INTEGER FUNCTION nfmpi_get_vara_int8_all(ncid, varid, start, count, i8vals)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=EightByteInt),    INTENT(OUT) :: i8vals(*)

Blocking put/get variable strided subarray APIs

INTEGER FUNCTION nfmpi_put_vars(ncid, varid, start, count, stride, buf, bufcount, datatype)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 <any valid type>,              INTENT(IN)  :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: datatype

INTEGER FUNCTION nfmpi_put_vars_all(ncid, varid, start, count, stride, buf, bufcount, datatype)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 <any valid type>,              INTENT(IN)  :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: datatype

INTEGER FUNCTION nfmpi_get_vars(ncid, varid, start, count, stride, buf, bufcount, datatype)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 <any valid type>,              INTENT(OUT) :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: datatype

INTEGER FUNCTION nfmpi_get_vars_all(ncid, varid, start, count, stride, buf, bufcount, datatype)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 <any valid type>,              INTENT(OUT) :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: datatype

INTEGER FUNCTION nfmpi_put_vars_text(ncid, varid, start, count, stride, text)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 CHARACTER(len=*),              INTENT(IN)  :: text

INTEGER FUNCTION nfmpi_put_vars_text_all(ncid, varid, start, count, stride, text)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 CHARACTER(len=*),              INTENT(IN)  :: text

INTEGER FUNCTION nfmpi_get_vars_text(ncid, varid, start, count, stride, text)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 CHARACTER(len=*),              INTENT(OUT) :: text

INTEGER FUNCTION nfmpi_get_vars_text_all(ncid, varid, start, count, stride, text)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 CHARACTER(len=*),              INTENT(OUT) :: text

INTEGER FUNCTION nfmpi_put_vars_int1(ncid, varid, start, count, stride, i1vals)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=OneByteInt),      INTENT(IN)  :: i1vals(*)

INTEGER FUNCTION nfmpi_put_vars_int1_all(ncid, varid, start, count, stride, i1vals)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=OneByteInt),      INTENT(IN)  :: i1vals(*)

INTEGER FUNCTION nfmpi_get_vars_int1(ncid, varid, start, count, stride, i1vals)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=OneByteInt),      INTENT(OUT) :: i1vals(*)

INTEGER FUNCTION nfmpi_get_vars_int1_all(ncid, varid, start, count, stride, i1vals)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=OneByteInt),      INTENT(OUT) :: i1vals(*)

INTEGER FUNCTION nfmpi_put_vars_int2(ncid, varid, start, count, stride, i2vals)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=TwoByteInt),      INTENT(INOUT) :: i2vals(*)

INTEGER FUNCTION nfmpi_put_vars_int2_all(ncid, varid, start, count, stride, i2vals)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=TwoByteInt),      INTENT(INOUT) :: i2vals(*)

INTEGER FUNCTION nfmpi_get_vars_int2(ncid, varid, start, count, stride, i2vals)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=TwoByteInt),      INTENT(OUT) :: i2vals(*)

INTEGER FUNCTION nfmpi_get_vars_int2_all(ncid, varid, start, count, stride, i2vals)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=TwoByteInt),      INTENT(OUT) :: i2vals(*)

INTEGER FUNCTION nfmpi_put_vars_int(ncid, varid, start, count, stride, ivals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER,                       INTENT(INOUT) :: ivals(*)

INTEGER FUNCTION nfmpi_put_vars_int_all(ncid, varid, start, count, stride, ivals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER,                       INTENT(INOUT) :: ivals(*)

INTEGER FUNCTION nfmpi_get_vars_int(ncid, varid, start, count, stride, ivals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER,                       INTENT(OUT) :: ivals(*)

INTEGER FUNCTION nfmpi_get_vars_int_all(ncid, varid, start, count, stride, ivals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER,                       INTENT(OUT) :: ivals(*)

INTEGER FUNCTION nfmpi_put_vars_real(ncid, varid, start, count, stride, rvals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 REAL,                          INTENT(INOUT) :: rvals(*)

INTEGER FUNCTION nfmpi_put_vars_real_all(ncid, varid, start, count, stride, rvals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 REAL,                          INTENT(INOUT) :: rvals(*)

INTEGER FUNCTION nfmpi_get_vars_real(ncid, varid, start, count, stride, rvals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 REAL,                          INTENT(OUT) :: rvals(*)

INTEGER FUNCTION nfmpi_get_vars_real_all(ncid, varid, start, count, stride, rvals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 REAL,                          INTENT(OUT) :: rvals(*)

INTEGER FUNCTION nfmpi_put_vars_double(ncid, varid, start, count, stride, dvals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 DOUBLE PRECISION,              INTENT(INOUT) :: dvals(*)

INTEGER FUNCTION nfmpi_put_vars_double_all(ncid, varid, start, count, stride, dvals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 DOUBLE PRECISION,              INTENT(INOUT) :: dvals(*)

INTEGER FUNCTION nfmpi_get_vars_double(ncid, varid, start, count, stride, dvals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 DOUBLE PRECISION,              INTENT(OUT) :: dvals(*)

INTEGER FUNCTION nfmpi_get_vars_double_all(ncid, varid, start, count, stride, dvals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 DOUBLE PRECISION,              INTENT(OUT) :: dvals(*)

INTEGER FUNCTION nfmpi_put_vars_int8(ncid, varid, start, count, stride, i8vals)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=EightByteInt),    INTENT(INOUT) :: i8vals(*)

INTEGER FUNCTION nfmpi_put_vars_int8_all(ncid, varid, start, count, stride, i8vals)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=EightByteInt),    INTENT(INOUT) :: i8vals(*)

INTEGER FUNCTION nfmpi_get_vars_int8(ncid, varid, start, count, stride, i8vals)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=EightByteInt),    INTENT(OUT) :: i8vals(*)

INTEGER FUNCTION nfmpi_get_vars_int8_all(ncid, varid, start, count, stride, i8vals)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=EightByteInt),    INTENT(OUT) :: i8vals(*)

Blocking put/get variable mapped and strided APIs

INTEGER FUNCTION nfmpi_put_varm(ncid, varid, start, count, stride, imap, buf, bufcount, datatype)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 <any valid type>,              INTENT(IN)  :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: datatype

INTEGER FUNCTION nfmpi_put_varm_all(ncid, varid, start, count, stride, imap, buf, bufcount, datatype)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 <any valid type>,              INTENT(IN)  :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: datatype

INTEGER FUNCTION nfmpi_get_varm(ncid, varid, start, count, stride, imap, buf, bufcount, datatype)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 <any valid type>,              INTENT(OUT) :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: datatype

INTEGER FUNCTION nfmpi_get_varm_all(ncid, varid, start, count, stride, imap, buf, bufcount, datatype)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 <any valid type>,              INTENT(OUT) :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: datatype

INTEGER FUNCTION nfmpi_put_varm_text(ncid, varid, start, count, stride, imap, text)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 CHARACTER(len=*),              INTENT(IN)  :: text

INTEGER FUNCTION nfmpi_put_varm_text_all(ncid, varid, start, count, stride, imap, text)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 CHARACTER(len=*),              INTENT(IN)  :: text

INTEGER FUNCTION nfmpi_get_varm_text(ncid, varid, start, count, stride, imap, text)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 CHARACTER(len=*),              INTENT(OUT) :: text

INTEGER FUNCTION nfmpi_get_varm_text_all(ncid, varid, start, count, stride, imap, text)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 CHARACTER(len=*),              INTENT(OUT) :: text

INTEGER FUNCTION nfmpi_put_varm_int1(ncid, varid, start, count, stride, imap, i1vals)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 INTEGER(KIND=OneByteInt),      INTENT(IN)  :: i1vals(*)

INTEGER FUNCTION nfmpi_put_varm_int1_all(ncid, varid, start, count, stride, imap, i1vals)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 INTEGER(KIND=OneByteInt),      INTENT(IN)  :: i1vals(*)

INTEGER FUNCTION nfmpi_get_varm_int1(ncid, varid, start, count, stride, imap, i1vals)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 INTEGER(KIND=OneByteInt),      INTENT(OUT) :: i1vals(*)

INTEGER FUNCTION nfmpi_get_varm_int1_all(ncid, varid, start, count, stride, imap, i1vals)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 INTEGER(KIND=OneByteInt),      INTENT(OUT) :: i1vals(*)

INTEGER FUNCTION nfmpi_put_varm_int2(ncid, varid, start, count, stride, imap, i2vals)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 INTEGER(KIND=TwoByteInt),      INTENT(INOUT) :: i2vals(*)

INTEGER FUNCTION nfmpi_put_varm_int2_all(ncid, varid, start, count, stride, imap, i2vals)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 INTEGER(KIND=TwoByteInt),      INTENT(INOUT) :: i2vals(*)

INTEGER FUNCTION nfmpi_get_varm_int2(ncid, varid, start, count, stride, imap, i2vals)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 INTEGER(KIND=TwoByteInt),      INTENT(OUT) :: i2vals(*)

INTEGER FUNCTION nfmpi_get_varm_int2_all(ncid, varid, start, count, stride, imap, i2vals)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 INTEGER(KIND=TwoByteInt),      INTENT(OUT) :: i2vals(*)

INTEGER FUNCTION nfmpi_put_varm_int (ncid, varid, start, count, stride, imap, ivals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 INTEGER,                       INTENT(INOUT) :: ivals(*)

INTEGER FUNCTION nfmpi_put_varm_int_all(ncid, varid, start, count, stride, imap, ivals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 INTEGER,                       INTENT(INOUT) :: ivals(*)

INTEGER FUNCTION nfmpi_get_varm_int (ncid, varid, start, count, stride, imap, ivals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 INTEGER,                       INTENT(OUT) :: ivals(*)

INTEGER FUNCTION nfmpi_get_varm_int_all(ncid, varid, start, count, stride, imap, ivals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 INTEGER,                       INTENT(OUT) :: ivals(*)

INTEGER FUNCTION nfmpi_put_varm_real(ncid, varid, start, count, stride, imap, rvals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 REAL,                          INTENT(INOUT) :: rvals(*)

INTEGER FUNCTION nfmpi_put_varm_real_all(ncid, varid, start, count, stride, imap, rvals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 REAL,                          INTENT(INOUT) :: rvals(*)

INTEGER FUNCTION nfmpi_get_varm_real(ncid, varid, start, count, stride, imap, rvals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 REAL,                          INTENT(OUT) :: rvals(*)

INTEGER FUNCTION nfmpi_get_varm_real_all(ncid, varid, start, count, stride, imap, rvals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 REAL,                          INTENT(OUT) :: rvals(*)

INTEGER FUNCTION nfmpi_put_varm_double(ncid, varid, start, count, stride, imap, dvals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 DOUBLE PRECISION,              INTENT(INOUT) :: dvals(*)

INTEGER FUNCTION nfmpi_put_varm_double_all(ncid, varid, start, count, stride, imap, dvals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 DOUBLE PRECISION,              INTENT(INOUT) :: dvals(*)

INTEGER FUNCTION nfmpi_get_varm_double(ncid, varid, start, count, stride, imap, dvals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 DOUBLE PRECISION,              INTENT(OUT) :: dvals(*)

INTEGER FUNCTION nfmpi_get_varm_double_all(ncid, varid, start, count, stride, imap, dvals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 DOUBLE PRECISION,              INTENT(OUT) :: dvals(*)

INTEGER FUNCTION nfmpi_put_varm_int8(ncid, varid, start, count, stride, imap, i8vals)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 INTEGER(KIND=EightByteInt),    INTENT(INOUT) :: i8vals(*)

INTEGER FUNCTION nfmpi_put_varm_int8_all(ncid, varid, start, count, stride, imap, i8vals)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 INTEGER(KIND=EightByteInt),    INTENT(INOUT) :: i8vals(*)

INTEGER FUNCTION nfmpi_get_varm_int8(ncid, varid, start, count, stride, imap, i8vals)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 INTEGER(KIND=EightByteInt),    INTENT(OUT) :: i8vals(*)

INTEGER FUNCTION nfmpi_get_varm_int8_all(ncid, varid, start, count, stride, imap, i8vals)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 INTEGER(KIND=EightByteInt),    INTENT(OUT) :: i8vals(*)

Nonblocking iput/iget the entire variable APIs

INTEGER FUNCTION nfmpi_iput_var(ncid, varid, buf, bufcount, datatype, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 <any valid type>,              INTENT(IN)  :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: datatype
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_var(ncid, varid, buf, bufcount, datatype, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 <any valid type>,              INTENT(OUT) :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: datatype
                 INTEGER,                       INTENT(OUT) :: req


INTEGER FUNCTION nfmpi_iput_var_text(ncid, varid, text, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 CHARACTER(len=*),              INTENT(IN)  :: text
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_var_text(ncid, varid, text, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 CHARACTER(len=*),              INTENT(OUT) :: text
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iput_var_int1(ncid, varid, i1vals, req)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=OneByteInt),      INTENT(IN)  :: i1vals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_var_int1(ncid, varid, i1vals, req)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=OneByteInt),      INTENT(OUT) :: i1vals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iput_var_int2(ncid, varid, i2vals, req)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=TwoByteInt),      INTENT(INOUT) :: i2vals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_var_int2(ncid, varid, i2vals, req)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=TwoByteInt),      INTENT(OUT) :: i2vals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iput_var_int(ncid, varid, ivals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(INOUT) :: ivals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_var_int(ncid, varid, ivals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(OUT) :: ivals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iput_var_real(ncid, varid, rvals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 REAL,                          INTENT(INOUT) :: rvals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_var_real(ncid, varid, rvals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 REAL,                          INTENT(OUT) :: rvals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iput_var_double(ncid, varid, dvals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 DOUBLE PRECISION,              INTENT(INOUT) :: dvals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_var_double(ncid, varid, dvals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 DOUBLE PRECISION,              INTENT(OUT) :: dvals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iput_var_int8(ncid, varid, i8vals, req)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=EightByteInt),    INTENT(INOUT) :: i8vals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_var_int8(ncid, varid, i8vals, req)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=EightByteInt),    INTENT(OUT) :: i8vals(*)
                 INTEGER,                       INTENT(OUT) :: req

Nonblocking iput/iget a single variable element APIs

INTEGER FUNCTION nfmpi_iput_var1(ncid, varid, index, buf, bufcount, datatype, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 <any valid type>,              INTENT(IN)  :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: datatype
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_var1(ncid, varid, index, buf, bufcount, datatype, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 <any valid type>,              INTENT(OUT) :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: datatype
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iput_var1_text(ncid, varid, index, text, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 CHARACTER,                     INTENT(IN)  :: text
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_var1_text(ncid, varid, index, text, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 CHARACTER,                     INTENT(OUT) :: text
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iput_var1_int1(ncid, varid, index, i1val, req)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 INTEGER(KIND=OneByteInt),      INTENT(IN)  :: i1val
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_var1_int1(ncid, varid, index, i1val, req)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 INTEGER(KIND=OneByteInt),      INTENT(OUT) :: i1val
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iput_var1_int2(ncid, varid, index, i2val, req)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 INTEGER(KIND=TwoByteInt),      INTENT(INOUT) :: i2val
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_var1_int2(ncid, varid, index, i2val, req)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 INTEGER(KIND=TwoByteInt),      INTENT(OUT) :: i2val
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iput_var1_int(ncid, varid, index, ival, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 INTEGER,                       INTENT(INOUT) :: ival
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_var1_int(ncid, varid, index, ival, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 INTEGER,                       INTENT(OUT) :: ival
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iput_var1_real(ncid, varid, index, rval, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 REAL,                          INTENT(INOUT) :: rval
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_var1_real(ncid, varid, index, rval, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 REAL,                          INTENT(OUT) :: rval
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iput_var1_double(ncid, varid, index, dval, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 DOUBLE PRECISION,              INTENT(INOUT) :: dval
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_var1_double(ncid, varid, index, dval, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 DOUBLE PRECISION,              INTENT(OUT) :: dval
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iput_var1_int8(ncid, varid, index, i8val, req)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 INTEGER(KIND=EightByteInt),    INTENT(INOUT) :: i8val
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_var1_int8(ncid, varid, index, i8val, req)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 INTEGER(KIND=EightByteInt),    INTENT(OUT) :: i8val
                 INTEGER,                       INTENT(OUT) :: req

Nonblocking iput/iget a variable subarray APIs

INTEGER FUNCTION nfmpi_iput_vara(ncid, varid, start, count, buf, bufcount, datatype, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 <any valid type>,              INTENT(IN)  :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: datatype
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_vara(ncid, varid, start, count, buf, bufcount, datatype, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 <any valid type>,              INTENT(OUT) :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: datatype
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iput_vara_text(ncid, varid, start, count, text, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 CHARACTER(len=*),              INTENT(IN)  :: text
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_vara_text(ncid, varid, start, count, text, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 CHARACTER(len=*),              INTENT(OUT) :: text
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iput_vara_int1(ncid, varid, start, count, i1vals, req)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=OneByteInt),      INTENT(IN)  :: i1vals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_vara_int1(ncid, varid, start, count, i1vals, req)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=OneByteInt),      INTENT(OUT) :: i1vals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iput_vara_int2(ncid, varid, start, count, i2vals, req)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=TwoByteInt),      INTENT(INOUT) :: i2vals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_vara_int2(ncid, varid, start, count, i2vals, req)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=TwoByteInt),      INTENT(OUT) :: i2vals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iput_vara_int(ncid, varid, start, count, ivals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER,                       INTENT(INOUT) :: ivals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_vara_int(ncid, varid, start, count, ivals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER,                       INTENT(OUT) :: ivals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iput_vara_real(ncid, varid, start, count, rvals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 REAL,                          INTENT(INOUT) :: rvals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_vara_real(ncid, varid, start, count, rvals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 REAL,                          INTENT(OUT) :: rvals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iput_vara_double(ncid, varid, start, count, dvals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 DOUBLE PRECISION,              INTENT(INOUT) :: dvals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_vara_double(ncid, varid, start, count, dvals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 DOUBLE PRECISION,              INTENT(OUT) :: dvals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iput_vara_int8(ncid, varid, start, count, i8vals, req)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=EightByteInt),    INTENT(INOUT) :: i8vals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_vara_int8(ncid, varid, start, count, i8vals, req)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=EightByteInt),    INTENT(OUT) :: i8vals(*)
                 INTEGER,                       INTENT(OUT) :: req

Nonblocking iput/iget a variable strided subarray APIs

INTEGER FUNCTION nfmpi_iput_vars(ncid, varid, start, count, stride, buf, bufcount, datatype, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 <any valid type>,              INTENT(IN)  :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: datatype
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_vars(ncid, varid, start, count, stride, buf, bufcount, datatype, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 <any valid type>,              INTENT(OUT) :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: datatype
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iput_vars_text(ncid, varid, start, count, stride, text, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 CHARACTER(len=*),              INTENT(IN)  :: text
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_vars_text(ncid, varid, start, count, stride, text, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 CHARACTER(len=*),              INTENT(OUT) :: text
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iput_vars_int1(ncid, varid, start, count, stride, i1vals, req)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=OneByteInt),      INTENT(IN)  :: i1vals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_vars_int1(ncid, varid, start, count, stride, i1vals, req)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=OneByteInt),      INTENT(OUT) :: i1vals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iput_vars_int2(ncid, varid, start, count, stride, i2vals, req)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=TwoByteInt),      INTENT(INOUT) :: i2vals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_vars_int2(ncid, varid, start, count, stride, i2vals, req)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=TwoByteInt),      INTENT(OUT) :: i2vals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iput_vars_int(ncid, varid, start, count, stride, ivals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER,                       INTENT(INOUT) :: ivals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_vars_int(ncid, varid, start, count, stride, ivals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER,                       INTENT(OUT) :: ivals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iput_vars_real(ncid, varid, start, count, stride, rvals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 REAL,                          INTENT(INOUT) :: rvals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_vars_real(ncid, varid, start, count, stride, rvals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 REAL,                          INTENT(OUT) :: rvals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iput_vars_double(ncid, varid, start, count, stride, dvals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 DOUBLE PRECISION,              INTENT(INOUT) :: dvals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_vars_double(ncid, varid, start, count, stride, dvals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 DOUBLE PRECISION,              INTENT(OUT) :: dvals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iput_vars_int8(ncid, varid, start, count, stride, i8vals, req)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=EightByteInt),    INTENT(INOUT) :: i8vals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_vars_int8(ncid, varid, start, count, stride, i8vals, req)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=EightByteInt),    INTENT(OUT) :: i8vals(*)
                 INTEGER,                       INTENT(OUT) :: req

Nonblocking iput/iget a variable mapped and stride APIs

INTEGER FUNCTION nfmpi_iput_varm(ncid, varid, start, count, stride, imap, buf, bufcount, datatype, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 <any valid type>,              INTENT(IN)  :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: datatype
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_varm(ncid, varid, start, count, stride, imap, buf, bufcount, datatype, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 <any valid type>,              INTENT(OUT) :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: datatype
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iput_varm_text(ncid, varid, start, count, stride, imap, text, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 CHARACTER(len=*),              INTENT(IN)  :: text
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_varm_text(ncid, varid, start, count, stride, imap, text, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 CHARACTER(len=*),              INTENT(OUT) :: text
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iput_varm_int1(ncid, varid, start, count, stride, imap, i1vals, req)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 INTEGER(KIND=OneByteInt),      INTENT(IN)  :: i1vals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_varm_int1(ncid, varid, start, count, stride, imap, i1vals, req)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 INTEGER(KIND=OneByteInt),      INTENT(OUT) :: i1vals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iput_varm_int2(ncid, varid, start, count, stride, imap, i2vals, req)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 INTEGER(KIND=TwoByteInt),      INTENT(INOUT) :: i2vals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_varm_int2(ncid, varid, start, count, stride, imap, i2vals, req)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 INTEGER(KIND=TwoByteInt),      INTENT(OUT) :: i2vals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iput_varm_int (ncid, varid, start, count, stride, imap, ivals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 INTEGER,                       INTENT(INOUT) :: ivals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_varm_int (ncid, varid, start, count, stride, imap, ivals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 INTEGER,                       INTENT(OUT) :: ivals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iput_varm_real(ncid, varid, start, count, stride, imap, rvals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 REAL,                          INTENT(INOUT) :: rvals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_varm_real(ncid, varid, start, count, stride, imap, rvals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 REAL,                          INTENT(OUT) :: rvals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iput_varm_double(ncid, varid, start, count, stride, imap, dvals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 DOUBLE PRECISION,              INTENT(INOUT) :: dvals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_varm_double(ncid, varid, start, count, stride, imap, dvals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 DOUBLE PRECISION,              INTENT(OUT) :: dvals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iput_varm_int8(ncid, varid, start, count, stride, imap, i8vals, req)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 INTEGER(KIND=EightByteInt),    INTENT(INOUT) :: i8vals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_varm_int8(ncid, varid, start, count, stride, imap, i8vals, req)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 INTEGER(KIND=EightByteInt),    INTENT(OUT) :: i8vals(*)
                 INTEGER,                       INTENT(OUT) :: req

Nonblocking buffered put APIs

INTEGER FUNCTION nfmpi_bput_var(ncid, varid, buf, bufcount, datatype, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 <any valid type>,              INTENT(IN)  :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: datatype
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bget_var(ncid, varid, buf, bufcount, datatype, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 <any valid type>,              INTENT(OUT) :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: datatype
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_var_text(ncid, varid, text, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 CHARACTER(len=*),              INTENT(IN)  :: text(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_var_int1(ncid, varid, i1vals, req)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=OneByteInt),      INTENT(IN)  :: i1vals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_var_int2(ncid, varid, i2vals, req)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=TwoByteInt),      INTENT(IN)  :: i2vals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_var_int(ncid, varid, ivals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: ivals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_var_real(ncid, varid, rvals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 REAL,                          INTENT(IN)  :: rvals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_var_double(ncid, varid, dvals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 DOUBLE PRECISION,              INTENT(IN)  :: dvals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_var_int8(ncid, varid, i8vals, req)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=EightByteInt),    INTENT(IN)  :: i8vals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_var1(ncid, varid, start, buf, bufcount, datatype, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 <any valid type>,              INTENT(IN)  :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: datatype
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bget_var1(ncid, varid, start, buf, bufcount, datatype, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 <any valid type>,              INTENT(OUT) :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: datatype
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_var1_text(ncid, varid, index, text, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 CHARACTER,                     INTENT(IN)  :: text
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_var1_int1(ncid, varid, index, i1val, req)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 INTEGER(KIND=OneByteInt),      INTENT(IN)  :: i1val
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_var1_int2(ncid, varid, index, i2val, req)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 INTEGER(KIND=TwoByteInt),      INTENT(IN)  :: i2val
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_var1_int(ncid, varid, index, ival, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 INTEGER,                       INTENT(IN)  :: ival
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_var1_real(ncid, varid, index, rval, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 REAL,                          INTENT(IN)  :: rval
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_var1_double(ncid, varid, index, dval, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 DOUBLE PRECISION,              INTENT(IN)  :: dval
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_var1_int8(ncid, varid, index, i8val, req)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: index(*)
                 INTEGER(KIND=EightByteInt),    INTENT(IN)  :: i8val
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_vara(ncid, varid, start, count, buf, bufcount, datatype, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 <any valid type>,              INTENT(IN)  :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: datatype
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bget_vara(ncid, varid, start, count, buf, bufcount, datatype, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 <any valid type>,              INTENT(OUT) :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: datatype
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_vara_text(ncid, varid, start, count, text, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 CHARACTER(len=*),              INTENT(IN)  :: text(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_vara_int1(ncid, varid, start, count, i1vals, req)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=OneByteInt),      INTENT(IN)  :: i1vals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_vara_int2(ncid, varid, start, count, i2vals, req)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=TwoByteInt),      INTENT(IN)  :: i2vals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_vara_int(ncid, varid, start, count, ivals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER,                       INTENT(IN)  :: ivals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_vara_real(ncid, varid, start, count, rvals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 REAL,                          INTENT(IN)  :: rvals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_vara_double(ncid, varid, start, count, dvals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 DOUBLE PRECISION,              INTENT(IN)  :: dvals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_vara_int8(ncid, varid, start, count, i8vals, req)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=EightByteInt),    INTENT(IN)  :: i8vals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_vars(ncid, varid, start, count, stride, imap, buf, bufcount, datatype, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 <any valid type>,              INTENT(IN)  :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: datatype
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bget_vars(ncid, varid, start, count, stride, imap, buf, bufcount, datatype, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 <any valid type>,              INTENT(OUT) :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: datatype
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_vars_text(ncid, varid, start, count, stride, text, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 CHARACTER(len=*),              INTENT(IN)  :: text
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_vars_int1(ncid, varid, start, count, stride, i1vals, req)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=OneByteInt),      INTENT(IN)  :: i1vals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_vars_int2(ncid, varid, start, count, stride, i2vals, req)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=TwoByteInt),      INTENT(IN)  :: i2vals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_vars_int(ncid, varid, start, count, stride, ivals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER,                       INTENT(IN)  :: ivals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_vars_real(ncid, varid, start, count, stride, rvals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 REAL,                          INTENT(IN)  :: rvals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_vars_double(ncid, varid, start, count, stride, dvals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 DOUBLE PRECISION,              INTENT(IN)  :: dvals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_vars_int8(ncid, varid, start, count, stride, i8vals, req)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=EightByteInt),    INTENT(IN)  :: i8vals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_varm(ncid, varid, start, count, stride, imap, buf, bufcount, datatype, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 <any valid type>,              INTENT(IN)  :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: datatype
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bget_varm(ncid, varid, start, count, stride, imap, buf, bufcount, datatype, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 <any valid type>,              INTENT(OUT) :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: datatype
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_varm_text(ncid, varid, start, count, stride, imap, text, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 CHARACTER(len=*),              INTENT(IN)  :: text
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_varm_int1(ncid, varid, start, count, stride, imap, i1vals, req)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 INTEGER(KIND=OneByteInt),      INTENT(IN)  :: i1vals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_varm_int2(ncid, varid, start, count, stride, imap, i2vals, req)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 INTEGER(KIND=TwoByteInt),      INTENT(IN)  :: i2vals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_varm_int (ncid, varid, start, count, stride, imap, ivals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 INTEGER,                       INTENT(IN)  :: ivals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_varm_real(ncid, varid, start, count, stride, imap, rvals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 REAL,                          INTENT(IN)  :: rvals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_varm_double(ncid, varid, start, count, stride, imap, dvals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 DOUBLE PRECISION,              INTENT(IN)  :: dvals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_varm_int8(ncid, varid, start, count, stride, imap, i8vals, req)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: start(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: count(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: stride(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: imap(*)
                 INTEGER(KIND=EightByteInt),    INTENT(IN)  :: i8vals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_buffer_attach(ncid, bufsize)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufsize

INTEGER FUNCTION nfmpi_buffer_detach(ncid)
                 INTEGER,                       INTENT(IN)  :: ncid

INTEGER FUNCTION nfmpi_inq_buffer_usage(ncid, usage)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(OUT) :: usage

INTEGER FUNCTION nfmpi_inq_buffer_size(ncid, buf_size)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(OUT) :: buf_size

Blocking put/get an array of values using filetype

INTEGER FUNCTION nfmpi_put_vard(ncid, varid, filetype, buf, bufcount, buftype)
                 INTEGER,                       INTENT(IN) :: ncid
                 INTEGER,                       INTENT(IN) :: varid
                 INTEGER,                       INTENT(IN) :: filetype
                 <any valid type>,              INTENT(IN) :: buf
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN) :: bufcount
                 INTEGER,                       INTENT(IN) :: buftype
                 INTEGER                                   :: nfmpi_put_vard

INTEGER FUNCTION nfmpi_put_vard_all(ncid, varid, filetype, buf, bufcount, buftype)
                 INTEGER,                       INTENT(IN) :: ncid
                 INTEGER,                       INTENT(IN) :: varid
                 INTEGER,                       INTENT(IN) :: filetype
                 <any valid type>,              INTENT(IN) :: buf
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN) :: bufcount
                 INTEGER,                       INTENT(IN) :: buftype
                 INTEGER                                   :: nfmpi_put_vard_all

INTEGER FUNCTION nfmpi_get_vard(ncid, varid, filetype, buf, bufcount, buftype)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: filetype
                 <any valid type>,              INTENT(OUT) :: buf
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: buftype
                 INTEGER                                    :: nfmpi_get_vard

INTEGER FUNCTION nfmpi_get_vard_all(ncid, varid, filetype, buf, bufcount, buftype)
                 INTEGER,                       INTENT(in)  :: ncid
                 INTEGER,                       INTENT(in)  :: varid
                 INTEGER,                       INTENT(in)  :: filetype
                 <any valid type>,              INTENT(OUT) :: buf
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(in)  :: buftype
                 INTEGER                                    :: nfmpi_get_vard_all

Blocking and nonblocking put/get a list of subarrays

INTEGER FUNCTION nfmpi_get_varn(ncid, varid, num, starts, counts, buf, bufcount, buftype)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 <any valid type>,              INTENT(OUT) :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: buftype

INTEGER FUNCTION nfmpi_get_varn_all(ncid, varid, num, starts, counts, buf, bufcount, buftype)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 <any valid type>,              INTENT(OUT) :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: buftype

INTEGER FUNCTION nfmpi_put_varn(ncid, varid, num, starts, counts, buf, bufcount, buftype)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 <any valid type>,              INTENT(IN)  :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: buftype

INTEGER FUNCTION nfmpi_put_varn_all(ncid, varid, num, starts, counts, buf, bufcount, buftype)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 <any valid type>,              INTENT(IN)  :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: buftype


INTEGER FUNCTION nfmpi_get_varn_text(ncid, varid, num, starts, counts, text)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 CHARACTER(len=*),              INTENT(OUT) :: text

INTEGER FUNCTION nfmpi_get_varn_int1(ncid, varid, num, starts, counts, i1vals)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 INTEGER(KIND=OneByteInt),      INTENT(OUT) :: i1vals(*)

INTEGER FUNCTION nfmpi_get_varn_int2(ncid, varid, num, starts, counts, i2vals)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 INTEGER(KIND=TwoByteInt),      INTENT(OUT) :: i2vals(*)

INTEGER FUNCTION nfmpi_get_varn_int(ncid, varid, num, starts, counts, ivals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 INTEGER,                       INTENT(OUT) :: ivals(*)

INTEGER FUNCTION nfmpi_get_varn_real(ncid, varid, num, starts, counts, rvals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 REAL,                          INTENT(OUT) :: rvals(*)

INTEGER FUNCTION nfmpi_get_varn_double(ncid, varid, num, starts, counts, dvals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 DOUBLE PRECISION,              INTENT(OUT) :: dvals(*)

INTEGER FUNCTION nfmpi_get_varn_int8(ncid, varid, num, starts, counts, i8vals)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 INTEGER(KIND=EightByteInt),    INTENT(OUT) :: i8vals(*)

INTEGER FUNCTION nfmpi_get_varn_text_all(ncid, varid, num, starts, counts, text)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 CHARACTER(len=*),              INTENT(OUT) :: text

INTEGER FUNCTION nfmpi_get_varn_int1_all(ncid, varid, num, starts, counts, i1vals)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 INTEGER(KIND=OneByteInt),      INTENT(OUT) :: i1vals(*)

INTEGER FUNCTION nfmpi_get_varn_int2_all(ncid, varid, num, starts, counts, i2vals)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 INTEGER(KIND=TwoByteInt),      INTENT(OUT) :: i2vals(*)

INTEGER FUNCTION nfmpi_get_varn_int_all(ncid, varid, num, starts, counts, ivals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 INTEGER,                       INTENT(OUT) :: ivals(*)

INTEGER FUNCTION nfmpi_get_varn_real_all(ncid, varid, num, starts, counts, rvals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 REAL,                          INTENT(OUT) :: rvals(*)

INTEGER FUNCTION nfmpi_get_varn_double_all(ncid, varid, num, starts, counts, dvals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 DOUBLE PRECISION,              INTENT(OUT) :: dvals(*)

INTEGER FUNCTION nfmpi_get_varn_int8_all(ncid, varid, num, starts, counts, i8vals)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 INTEGER(KIND=EightByteInt),    INTENT(OUT) :: i8vals(*)


INTEGER FUNCTION nfmpi_put_varn_text(ncid, varid, num, starts, counts, text)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 CHARACTER(len=*),              INTENT(IN)  :: text

INTEGER FUNCTION nfmpi_put_varn_int1(ncid, varid, num, starts, counts, i1vals)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 INTEGER(KIND=OneByteInt),      INTENT(IN)  :: i1vals(*)

INTEGER FUNCTION nfmpi_put_varn_int2(ncid, varid, num, starts, counts, i2vals)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 INTEGER(KIND=TwoByteInt),      INTENT(INOUT) :: i2vals(*)

INTEGER FUNCTION nfmpi_put_varn_int(ncid, varid, num, starts, counts, ivals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 INTEGER,                       INTENT(INOUT) :: ivals(*)

INTEGER FUNCTION nfmpi_put_varn_real(ncid, varid, num, starts, counts, rvals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 REAL,                          INTENT(INOUT) :: rvals(*)

INTEGER FUNCTION nfmpi_put_varn_double(ncid, varid, num, starts, counts, dvals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 DOUBLE PRECISION,              INTENT(INOUT) :: dvals(*)

INTEGER FUNCTION nfmpi_put_varn_int8(ncid, varid, num, starts, counts, i8vals)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 INTEGER(KIND=EightByteInt),    INTENT(INOUT) :: i8vals(*)

INTEGER FUNCTION nfmpi_put_varn_text_all(ncid, varid, num, starts, counts, text)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 CHARACTER(len=*),              INTENT(IN)  :: text

INTEGER FUNCTION nfmpi_put_varn_int1_all(ncid, varid, num, starts, counts, i1vals)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 INTEGER(KIND=OneByteInt),      INTENT(IN)  :: i1vals(*)

INTEGER FUNCTION nfmpi_put_varn_int2_all(ncid, varid, num, starts, counts, i2vals)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 INTEGER(KIND=TwoByteInt),      INTENT(INOUT) :: i2vals(*)

INTEGER FUNCTION nfmpi_put_varn_int_all(ncid, varid, num, starts, counts, ivals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 INTEGER,                       INTENT(INOUT) :: ivals(*)

INTEGER FUNCTION nfmpi_put_varn_real_all(ncid, varid, num, starts, counts, rvals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 REAL,                          INTENT(INOUT) :: rvals(*)

INTEGER FUNCTION nfmpi_put_varn_double_all(ncid, varid, num, starts, counts, dvals)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 DOUBLE PRECISION,              INTENT(INOUT) :: dvals(*)

INTEGER FUNCTION nfmpi_put_varn_int8_all(ncid, varid, num, starts, counts, i8vals)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 INTEGER(KIND=EightByteInt),    INTENT(INOUT) :: i8vals(*)

INTEGER FUNCTION nfmpi_iget_varn(ncid, varid, num, starts, counts, buf, bufcount, buftype, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 <any valid type>,              INTENT(OUT) :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: buftype
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iput_varn(ncid, varid, num, starts, counts, buf, bufcount, buftype, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 <any valid type>,              INTENT(IN)  :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: buftype
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_varn_text(ncid, varid, num, starts, counts, text, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 CHARACTER(len=*),              INTENT(OUT) :: text
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_varn_int1(ncid, varid, num, starts, counts, i1vals, req)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 INTEGER(KIND=OneByteInt),      INTENT(OUT) :: i1vals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_varn_int2(ncid, varid, num, starts, counts, i2vals, req)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 INTEGER(KIND=TwoByteInt),      INTENT(OUT) :: i2vals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_varn_int(ncid, varid, num, starts, counts, ivals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 INTEGER,                       INTENT(OUT) :: ivals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_varn_real(ncid, varid, num, starts, counts, rvals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 REAL,                          INTENT(OUT) :: rvals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_varn_double(ncid, varid, num, starts, counts, dvals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 DOUBLE PRECISION,              INTENT(OUT) :: dvals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iget_varn_int8(ncid, varid, num, starts, counts, i8vals, req)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 INTEGER(KIND=EightByteInt),    INTENT(OUT) :: i8vals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iput_varn_text(ncid, varid, num, starts, counts, text, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 CHARACTER(len=*),              INTENT(IN)  :: text
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iput_varn_int1(ncid, varid, num, starts, counts, i1vals, req)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 INTEGER(KIND=OneByteInt),      INTENT(IN)  :: i1vals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iput_varn_int2(ncid, varid, num, starts, counts, i2vals, req)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 INTEGER(KIND=TwoByteInt),      INTENT(INOUT) :: i2vals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iput_varn_int(ncid, varid, num, starts, counts, ivals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 INTEGER,                       INTENT(INOUT) :: ivals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iput_varn_real(ncid, varid, num, starts, counts, rvals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 REAL,                          INTENT(INOUT) :: rvals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iput_varn_double(ncid, varid, num, starts, counts, dvals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 DOUBLE PRECISION,              INTENT(INOUT) :: dvals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_iput_varn_int8(ncid, varid, num, starts, counts, i8vals, req)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 INTEGER(KIND=EightByteInt),    INTENT(INOUT) :: i8vals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_varn(ncid, varid, num, starts, counts, buf, bufcount, buftype, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 <any valid type>,              INTENT(IN)  :: buf(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: bufcount
                 INTEGER,                       INTENT(IN)  :: buftype
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_varn_text(ncid, varid, num, starts, counts, text, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 CHARACTER(len=*),              INTENT(IN)  :: text
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_varn_int1(ncid, varid, num, starts, counts, i1vals, req)
                 integer, parameter :: OneByteInt = selected_int_kind(2)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 INTEGER(KIND=OneByteInt),      INTENT(IN)  :: i1vals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_varn_int2(ncid, varid, num, starts, counts, i2vals, req)
                 integer, parameter :: TwoByteInt = selected_int_kind(4)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 INTEGER(KIND=TwoByteInt),      INTENT(INOUT) :: i2vals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_varn_int(ncid, varid, num, starts, counts, ivals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 INTEGER,                       INTENT(INOUT) :: ivals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_varn_real(ncid, varid, num, starts, counts, rvals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 REAL,                          INTENT(INOUT) :: rvals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_varn_double(ncid, varid, num, starts, counts, dvals, req)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 DOUBLE PRECISION,              INTENT(INOUT) :: dvals(*)
                 INTEGER,                       INTENT(OUT) :: req

INTEGER FUNCTION nfmpi_bput_varn_int8(ncid, varid, num, starts, counts, i8vals, req)
                 integer, parameter :: EightByteInt = selected_int_kind(18)
                 INTEGER,                       INTENT(IN)  :: ncid
                 INTEGER,                       INTENT(IN)  :: varid
                 INTEGER,                       INTENT(IN)  :: num
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: starts(*)
                 INTEGER(KIND=MPI_OFFSET_KIND), INTENT(IN)  :: counts(*)
                 INTEGER(KIND=EightByteInt),    INTENT(INOUT) :: i8vals(*)
                 INTEGER,                       INTENT(OUT) :: req

Next: , Previous: , Up: Top   [Index]