attr.c#40ncx_len_NC_attrV(nc_type type, size_t nelems)
#45 return ncx_len_char(nelems);
#47 return ncx_len_short(nelems);
#49 return ncx_len_int(nelems);
#51 return ncx_len_float(nelems);
#53 return ncx_len_double(nelems);
#55 return ncx_len_ubyte(nelems);
#57 return ncx_len_ushort(nelems);
#59 return ncx_len_uint(nelems);
#61 return ncx_len_int64(nelems);
#63 return ncx_len_uint64(nelems);
#75 size_t nelems)
#78 const size_t xsz = ncx_len_NC_attrV(typenelems);
#81 assert(!(xsz == 0 && nelems != 0));
#93 attrp->nelems = nelems;
#111 size_t nelems)
#126 attrp = new_x_NC_attr(strptypenelems);
#141  rattrp->typerattrp->nelems);
#160 if(ncap->nelems == 0)
#167 NC_attr *const *const end = &app[ncap->nelems];
#174 ncap->nelems = 0;
#209 if(ref->nelems != 0)
#211 const size_t sz = ref->nelems * sizeof(NC_attr *);
#217 ncap->nalloc = ref->nelems;
#220 ncap->nelems = 0;
#224 NC_attr *const *const end = &app[ref->nelems];
#225 for( /*NADA*/; app < enddrpp++, app++, ncap->nelems++)
#242 assert(ncap->nelems == ref->nelems);
#262 assert(ncap->nelems == 0);
#270 else if(ncap->nelems +1 > ncap->nalloc)
#283 ncap->value[ncap->nelems] = newelemp;
#284 ncap->nelems++;
#295 if(ncap->nelems == 0 || (unsigned long) elem >= ncap->nelems)
#318 else if(varid >= 0 && (size_t) varid < ncp->vars.nelems)
#345 if(ncap->nelems == 0)
#356 for(attrid = 0; attrid < ncap->nelemsattrid++, attrpp++)
#481 *lenp = attrp->nelems;
#593 for(attrid = 0; (size_t) attrid < ncap->nelemsattrid++, attrpp++)
#604 if( (size_t) attrid == ncap->nelems )
#609 for(attrid++; (size_t) attrid < ncap->nelemsattrid++)
#616 ncap->nelems--;
#625ncx_pad_putn_Iuchar(void **xpp, size_t nelems, const uchar *tpnc_type type)
#631 return ncx_pad_putn_schar_uchar(xppnelemstp);
#633 return ncx_pad_putn_short_uchar(xppnelemstp);
#635 return ncx_putn_int_uchar(xppnelemstp);
#637 return ncx_putn_float_uchar(xppnelemstp);
#639 return ncx_putn_double_uchar(xppnelemstp);
#641 return ncx_pad_putn_uchar_uchar(xppnelemstp);
#643 return ncx_putn_ushort_uchar(xppnelemstp);
#645 return ncx_putn_uint_uchar(xppnelemstp);
#647 return ncx_putn_longlong_uchar(xppnelemstp);
#649 return ncx_putn_ulonglong_uchar(xppnelemstp);
#657ncx_pad_getn_Iuchar(const void **xpp, size_t nelemsuchar *tpnc_type type)
#663 return ncx_pad_getn_schar_uchar(xppnelemstp);
#665 return ncx_pad_getn_short_uchar(xppnelemstp);
#667 return ncx_getn_int_uchar(xppnelemstp);
#669 return ncx_getn_float_uchar(xppnelemstp);
#671 return ncx_getn_double_uchar(xppnelemstp);
#673 return ncx_pad_getn_uchar_uchar(xppnelemstp);
#675 return ncx_getn_ushort_uchar(xppnelemstp);
#677 return ncx_getn_uint_uchar(xppnelemstp);
#679 return ncx_getn_longlong_uchar(xppnelemstp);
#681 return ncx_getn_ulonglong_uchar(xppnelemstp);
#690ncx_pad_putn_Ischar(void **xpp, size_t nelems, const schar *tpnc_type type)
#696 return ncx_pad_putn_schar_schar(xppnelemstp);
#698 return ncx_pad_putn_short_schar(xppnelemstp);
#700 return ncx_putn_int_schar(xppnelemstp);
#702 return ncx_putn_float_schar(xppnelemstp);
#704 return ncx_putn_double_schar(xppnelemstp);
#706 return ncx_pad_putn_uchar_schar(xppnelemstp);
#708 return ncx_putn_ushort_schar(xppnelemstp);
#710 return ncx_putn_uint_schar(xppnelemstp);
#712 return ncx_putn_longlong_schar(xppnelemstp);
#714 return ncx_putn_ulonglong_schar(xppnelemstp);
#722ncx_pad_getn_Ischar(const void **xpp, size_t nelemsschar *tpnc_type type)
#728 return ncx_pad_getn_schar_schar(xppnelemstp);
#730 return ncx_pad_getn_short_schar(xppnelemstp);
#732 return ncx_getn_int_schar(xppnelemstp);
#734 return ncx_getn_float_schar(xppnelemstp);
#736 return ncx_getn_double_schar(xppnelemstp);
#738 return ncx_pad_getn_uchar_schar(xppnelemstp);
#740 return ncx_getn_ushort_schar(xppnelemstp);
#742 return ncx_getn_uint_schar(xppnelemstp);
#744 return ncx_getn_longlong_schar(xppnelemstp);
#746 return ncx_getn_ulonglong_schar(xppnelemstp);
#755ncx_pad_putn_Ishort(void **xpp, size_t nelems, const short *tpnc_type type)
#761 return ncx_pad_putn_schar_short(xppnelemstp);
#763 return ncx_pad_putn_short_short(xppnelemstp);
#765 return ncx_putn_int_short(xppnelemstp);
#767 return ncx_putn_float_short(xppnelemstp);
#769 return ncx_putn_double_short(xppnelemstp);
#771 return ncx_pad_putn_uchar_short(xppnelemstp);
#773 return ncx_putn_ushort_short(xppnelemstp);
#775 return ncx_putn_uint_short(xppnelemstp);
#777 return ncx_putn_longlong_short(xppnelemstp);
#779 return ncx_putn_ulonglong_short(xppnelemstp);
#787ncx_pad_getn_Ishort(const void **xpp, size_t nelems, short *tpnc_type type)
#793 return ncx_pad_getn_schar_short(xppnelemstp);
#795 return ncx_pad_getn_short_short(xppnelemstp);
#797 return ncx_getn_int_short(xppnelemstp);
#799 return ncx_getn_float_short(xppnelemstp);
#801 return ncx_getn_double_short(xppnelemstp);
#803 return ncx_pad_getn_uchar_short(xppnelemstp);
#805 return ncx_getn_ushort_short(xppnelemstp);
#807 return ncx_getn_uint_short(xppnelemstp);
#809 return ncx_getn_longlong_short(xppnelemstp);
#811 return ncx_getn_ulonglong_short(xppnelemstp);
#820ncx_pad_putn_Iint(void **xpp, size_t nelems, const int *tpnc_type type)
#826 return ncx_pad_putn_schar_int(xppnelemstp);
#828 return ncx_pad_putn_short_int(xppnelemstp);
#830 return ncx_putn_int_int(xppnelemstp);
#832 return ncx_putn_float_int(xppnelemstp);
#834 return ncx_putn_double_int(xppnelemstp);
#836 return ncx_pad_putn_uchar_int(xppnelemstp);
#838 return ncx_putn_ushort_int(xppnelemstp);
#840 return ncx_putn_uint_int(xppnelemstp);
#842 return ncx_putn_longlong_int(xppnelemstp);
#844 return ncx_putn_ulonglong_int(xppnelemstp);
#852ncx_pad_getn_Iint(const void **xpp, size_t nelems, int *tpnc_type type)
#858 return ncx_pad_getn_schar_int(xppnelemstp);
#860 return ncx_pad_getn_short_int(xppnelemstp);
#862 return ncx_getn_int_int(xppnelemstp);
#864 return ncx_getn_float_int(xppnelemstp);
#866 return ncx_getn_double_int(xppnelemstp);
#868 return ncx_pad_getn_uchar_int(xppnelemstp);
#870 return ncx_getn_ushort_int(xppnelemstp);
#872 return ncx_getn_uint_int(xppnelemstp);
#874 return ncx_getn_longlong_int(xppnelemstp);
#876 return ncx_getn_ulonglong_int(xppnelemstp);
#885ncx_pad_putn_Ifloat(void **xpp, size_t nelems, const float *tpnc_type type)
#891 return ncx_pad_putn_schar_float(xppnelemstp);
#893 return ncx_pad_putn_short_float(xppnelemstp);
#895 return ncx_putn_int_float(xppnelemstp);
#897 return ncx_putn_float_float(xppnelemstp);
#899 return ncx_putn_double_float(xppnelemstp);
#901 return ncx_pad_putn_uchar_float(xppnelemstp);
#903 return ncx_putn_ushort_float(xppnelemstp);
#905 return ncx_putn_uint_float(xppnelemstp);
#907 return ncx_putn_longlong_float(xppnelemstp);
#909 return ncx_putn_ulonglong_float(xppnelemstp);
#917ncx_pad_getn_Ifloat(const void **xpp, size_t nelems, float *tpnc_type type)
#923 return ncx_pad_getn_schar_float(xppnelemstp);
#925 return ncx_pad_getn_short_float(xppnelemstp);
#927 return ncx_getn_int_float(xppnelemstp);
#929 return ncx_getn_float_float(xppnelemstp);
#931 return ncx_getn_double_float(xppnelemstp);
#933 return ncx_pad_getn_uchar_float(xppnelemstp);
#935 return ncx_getn_ushort_float(xppnelemstp);
#937 return ncx_getn_uint_float(xppnelemstp);
#939 return ncx_getn_longlong_float(xppnelemstp);
#941 return ncx_getn_ulonglong_float(xppnelemstp);
#950ncx_pad_putn_Idouble(void **xpp, size_t nelems, const double *tpnc_type type)
#956 return ncx_pad_putn_schar_double(xppnelemstp);
#958 return ncx_pad_putn_short_double(xppnelemstp);
#960 return ncx_putn_int_double(xppnelemstp);
#962 return ncx_putn_float_double(xppnelemstp);
#964 return ncx_putn_double_double(xppnelemstp);
#966 return ncx_pad_putn_uchar_double(xppnelemstp);
#968 return ncx_putn_ushort_double(xppnelemstp);
#970 return ncx_putn_uint_double(xppnelemstp);
#972 return ncx_putn_longlong_double(xppnelemstp);
#974 return ncx_putn_ulonglong_double(xppnelemstp);
#982ncx_pad_getn_Idouble(const void **xpp, size_t nelems, double *tpnc_type type)
#988 return ncx_pad_getn_schar_double(xppnelemstp);
#990 return ncx_pad_getn_short_double(xppnelemstp);
#992 return ncx_getn_int_double(xppnelemstp);
#994 return ncx_getn_float_double(xppnelemstp);
#996 return ncx_getn_double_double(xppnelemstp);
#998 return ncx_pad_getn_uchar_double(xppnelemstp);
#1000 return ncx_getn_ushort_double(xppnelemstp);
#1002 return ncx_getn_uint_double(xppnelemstp);
#1004 return ncx_getn_longlong_double(xppnelemstp);
#1006 return ncx_getn_ulonglong_double(xppnelemstp);
#1016ncx_pad_putn_Ilong(void **xpp, size_t nelems, const long *tpnc_type type)
#1022 return ncx_pad_putn_schar_long(xppnelemstp);
#1024 return ncx_pad_putn_short_long(xppnelemstp);
#1026 return ncx_putn_int_long(xppnelemstp);
#1028 return ncx_putn_float_long(xppnelemstp);
#1030 return ncx_putn_double_long(xppnelemstp);
#1032 return ncx_pad_putn_uchar_long(xppnelemstp);
#1034 return ncx_putn_ushort_long(xppnelemstp);
#1036 return ncx_putn_uint_long(xppnelemstp);
#1038 return ncx_putn_longlong_long(xppnelemstp);
#1040 return ncx_putn_ulonglong_long(xppnelemstp);
#1048ncx_pad_getn_Ilong(const void **xpp, size_t nelems, long *tpnc_type type)
#1054 return ncx_pad_getn_schar_long(xppnelemstp);
#1056 return ncx_pad_getn_short_long(xppnelemstp);
#1058 return ncx_getn_int_long(xppnelemstp);
#1060 return ncx_getn_float_long(xppnelemstp);
#1062 return ncx_getn_double_long(xppnelemstp);
#1064 return ncx_pad_getn_uchar_long(xppnelemstp);
#1066 return ncx_getn_ushort_long(xppnelemstp);
#1068 return ncx_getn_uint_long(xppnelemstp);
#1070 return ncx_getn_longlong_long(xppnelemstp);
#1072 return ncx_getn_ulonglong_long(xppnelemstp);
#1082ncx_pad_putn_Ilonglong(void **xpp, size_t nelems, const longlong *tpnc_type type)
#1088 return ncx_pad_putn_schar_longlong(xppnelemstp);
#1090 return ncx_pad_putn_short_longlong(xppnelemstp);
#1092 return ncx_putn_int_longlong(xppnelemstp);
#1094 return ncx_putn_float_longlong(xppnelemstp);
#1096 return ncx_putn_double_longlong(xppnelemstp);
#1098 return ncx_pad_putn_uchar_longlong(xppnelemstp);
#1100 return ncx_putn_ushort_longlong(xppnelemstp);
#1102 return ncx_putn_uint_longlong(xppnelemstp);
#1104 return ncx_putn_longlong_longlong(xppnelemstp);
#1106 return ncx_putn_ulonglong_longlong(xppnelemstp);
#1114ncx_pad_getn_Ilonglong(const void **xpp, size_t nelemslonglong *tpnc_type type)
#1120 return ncx_pad_getn_schar_longlong(xppnelemstp);
#1122 return ncx_pad_getn_short_longlong(xppnelemstp);
#1124 return ncx_getn_int_longlong(xppnelemstp);
#1126 return ncx_getn_float_longlong(xppnelemstp);
#1128 return ncx_getn_double_longlong(xppnelemstp);
#1130 return ncx_pad_getn_uchar_longlong(xppnelemstp);
#1132 return ncx_getn_ushort_longlong(xppnelemstp);
#1134 return ncx_getn_uint_longlong(xppnelemstp);
#1136 return ncx_getn_longlong_longlong(xppnelemstp);
#1138 return ncx_getn_ulonglong_longlong(xppnelemstp);
#1147ncx_pad_putn_Iushort(void **xpp, size_t nelems, const ushort *tpnc_type type)
#1153 return ncx_pad_putn_schar_ushort(xppnelemstp);
#1155 return ncx_pad_putn_short_ushort(xppnelemstp);
#1157 return ncx_putn_int_ushort(xppnelemstp);
#1159 return ncx_putn_float_ushort(xppnelemstp);
#1161 return ncx_putn_double_ushort(xppnelemstp);
#1163 return ncx_pad_putn_uchar_ushort(xppnelemstp);
#1165 return ncx_putn_ushort_ushort(xppnelemstp);
#1167 return ncx_putn_uint_ushort(xppnelemstp);
#1169 return ncx_putn_longlong_ushort(xppnelemstp);
#1171 return ncx_putn_ulonglong_ushort(xppnelemstp);
#1179ncx_pad_getn_Iushort(const void **xpp, size_t nelemsushort *tpnc_type type)
#1185 return ncx_pad_getn_schar_ushort(xppnelemstp);
#1187 return ncx_pad_getn_short_ushort(xppnelemstp);
#1189 return ncx_getn_int_ushort(xppnelemstp);
#1191 return ncx_getn_float_ushort(xppnelemstp);
#1193 return ncx_getn_double_ushort(xppnelemstp);
#1195 return ncx_pad_getn_uchar_ushort(xppnelemstp);
#1197 return ncx_getn_ushort_ushort(xppnelemstp);
#1199 return ncx_getn_uint_ushort(xppnelemstp);
#1201 return ncx_getn_longlong_ushort(xppnelemstp);
#1203 return ncx_getn_ulonglong_ushort(xppnelemstp);
#1212ncx_pad_putn_Iuint(void **xpp, size_t nelems, const uint *tpnc_type type)
#1218 return ncx_pad_putn_schar_uint(xppnelemstp);
#1220 return ncx_pad_putn_short_uint(xppnelemstp);
#1222 return ncx_putn_int_uint(xppnelemstp);
#1224 return ncx_putn_float_uint(xppnelemstp);
#1226 return ncx_putn_double_uint(xppnelemstp);
#1228 return ncx_pad_putn_uchar_uint(xppnelemstp);
#1230 return ncx_putn_ushort_uint(xppnelemstp);
#1232 return ncx_putn_uint_uint(xppnelemstp);
#1234 return ncx_putn_longlong_uint(xppnelemstp);
#1236 return ncx_putn_ulonglong_uint(xppnelemstp);
#1244ncx_pad_getn_Iuint(const void **xpp, size_t nelemsuint *tpnc_type type)
#1250 return ncx_pad_getn_schar_uint(xppnelemstp);
#1252 return ncx_pad_getn_short_uint(xppnelemstp);
#1254 return ncx_getn_int_uint(xppnelemstp);
#1256 return ncx_getn_float_uint(xppnelemstp);
#1258 return ncx_getn_double_uint(xppnelemstp);
#1260 return ncx_pad_getn_uchar_uint(xppnelemstp);
#1262 return ncx_getn_ushort_uint(xppnelemstp);
#1264 return ncx_getn_uint_uint(xppnelemstp);
#1266 return ncx_getn_longlong_uint(xppnelemstp);
#1268 return ncx_getn_ulonglong_uint(xppnelemstp);
#1277ncx_pad_putn_Iulonglong(void **xpp, size_t nelems, const ulonglong *tpnc_type type)
#1283 return ncx_pad_putn_schar_ulonglong(xppnelemstp);
#1285 return ncx_pad_putn_short_ulonglong(xppnelemstp);
#1287 return ncx_putn_int_ulonglong(xppnelemstp);
#1289 return ncx_putn_float_ulonglong(xppnelemstp);
#1291 return ncx_putn_double_ulonglong(xppnelemstp);
#1293 return ncx_pad_putn_uchar_ulonglong(xppnelemstp);
#1295 return ncx_putn_ushort_ulonglong(xppnelemstp);
#1297 return ncx_putn_uint_ulonglong(xppnelemstp);
#1299 return ncx_putn_longlong_ulonglong(xppnelemstp);
#1301 return ncx_putn_ulonglong_ulonglong(xppnelemstp);
#1309ncx_pad_getn_Iulonglong(const void **xpp, size_t nelemsulonglong *tpnc_type type)
#1315 return ncx_pad_getn_schar_ulonglong(xppnelemstp);
#1317 return ncx_pad_getn_short_ulonglong(xppnelemstp);
#1319 return ncx_getn_int_ulonglong(xppnelemstp);
#1321 return ncx_getn_float_ulonglong(xppnelemstp);
#1323 return ncx_getn_double_ulonglong(xppnelemstp);
#1325 return ncx_pad_getn_uchar_ulonglong(xppnelemstp);
#1327 return ncx_getn_ushort_ulonglong(xppnelemstp);
#1329 return ncx_getn_uint_ulonglong(xppnelemstp);
#1331 return ncx_getn_longlong_ulonglong(xppnelemstp);
#1333 return ncx_getn_ulonglong_ulonglong(xppnelemstp);
#1344dispatchput(void **xpp, size_t nelems, const void* tp,
#1349        return ncx_pad_putn_text(xpp,nelems, (char *)tp);
#1351        return ncx_pad_putn_Ischar(xppnelems, (schar*)tpatype);
#1353        return ncx_pad_putn_Ishort(xppnelems, (short*)tpatype);
#1355          return ncx_pad_putn_Iint(xppnelems, (int*)tpatype);
#1357        return ncx_pad_putn_Ifloat(xppnelems, (float*)tpatype);
#1359        return ncx_pad_putn_Idouble(xppnelems, (double*)tpatype);
#1361        return ncx_pad_putn_Iuchar(xpp,nelems, (uchar *)tpatype);
#1363          return ncx_pad_putn_Ilonglong(xppnelems, (longlong*)tpatype);
#1365          return ncx_pad_putn_Iushort(xppnelems, (ushort*)tpatype);
#1367          return ncx_pad_putn_Iuint(xppnelems, (uint*)tpatype);
#1369          return ncx_pad_putn_Iulonglong(xppnelems, (ulonglong*)tpatype);
#1384 size_t nelems,
#1420    if((unsigned long) nelems > X_INT_MAX) /* backward compat */
#1423    if(nelems != 0 && value == NULL)
#1432     const size_t xsz = ncx_len_NC_attrV(typenelems);
#1440            attrp->nelems = nelems;
#1442            if(nelems != 0) {
#1444                status = dispatchput(&xpnelems, (const void*)valuetypememtype);
#1465        if(ncap->nelems >= NC_MAX_ATTRS) return NC_EMAXATTS;
#1471    attrp = new_NC_attr(nametypenelems);
#1474    if(nelems != 0) {
#1476        status = dispatchput(&xpnelems, (const void*)valuetypememtype);
#1512    if(attrp->nelems == 0) return NC_NOERR;
#1524        return ncx_pad_getn_text(&xpattrp->nelems , (char *)value);
#1526        return ncx_pad_getn_Ischar(&xp,attrp->nelems,(schar*)value,attrp->type);
#1528        return ncx_pad_getn_Ishort(&xp,attrp->nelems,(short*)value,attrp->type);
#1530          return ncx_pad_getn_Iint(&xp,attrp->nelems,(int*)value,attrp->type);
#1532        return ncx_pad_getn_Ifloat(&xp,attrp->nelems,(float*)value,attrp->type);
#1534        return ncx_pad_getn_Idouble(&xp,attrp->nelems,(double*)value,attrp->type);
#1536          return ncx_pad_getn_Ilonglong(&xp,attrp->nelems,(longlong*)value,attrp->type);
#1538        return ncx_pad_getn_Iuchar(&xpattrp->nelems , (uchar *)valueattrp->type);
#1540          return ncx_pad_getn_Iushort(&xp,attrp->nelems,(ushort*)value,attrp->type);
#1542          return ncx_pad_getn_Iuint(&xp,attrp->nelems,(uint*)value,attrp->type);
#1544          return ncx_pad_getn_Iulonglong(&xp,attrp->nelems,(ulonglong*)value,attrp->type);
cache.c#407 size_t nelems;
#418        for(nelems=1,j=0;j<nclistlength(var->array.dimsettrans);j++) {
#420            nelems *= dim->dim.declsize;
#422        if(nelems <= nccomm->cdf.smallsizelimit
#430                    tmp,(unsigned long)nelems);
dapdump.h#22    size_t nelems; /*# elements*/
debug.c#31chkcalloc(size_t size, size_t nelems)
#33    return chkmalloc(size*nelems);
dim.c#95 if(ncap->nelems == 0)
#102 for(; (size_t) dimid < ncap->nelems
#107 if(dimid >= ncap->nelems)
#134   if(ncap->nelems == 0)
#169 if(ncap->nelems == 0)
#176 NC_dim *const *const end = &dpp[ncap->nelems];
#183 ncap->nelems = 0;
#221 if(ref->nelems != 0)
#223 const size_t sz = ref->nelems * sizeof(NC_dim *);
#228 ncap->nalloc = ref->nelems;
#231 ncap->nelems = 0;
#235 NC_dim *const *const end = &dpp[ref->nelems];
#236 for( /*NADA*/; dpp < enddrpp++, dpp++, ncap->nelems++)
#253 assert(ncap->nelems == ref->nelems);
#273 assert(ncap->nelems == 0);
#281 else if(ncap->nelems +1 > ncap->nalloc)
#293 NC_hashmapAddDim(ncap, (long)ncap->nelemsnewelemp->name->cp);
#294 ncap->value[ncap->nelems] = newelemp;
#295 ncap->nelems++;
#306 if(ncap->nelems == 0 || (unsigned long) elem >= ncap->nelems)
#359 if(ncp->dims.nelems >= NC_MAX_DIMS)
#377 *dimidp = (int)ncp->dims.nelems -1;
dvar.c#547nc_set_var_chunk_cache(int ncid, int varid, size_t size, size_t nelems,
#554       nelemspreemption);
error.c#62print_n_size_t(size_t nelems, const size_t *array)
#65 while(nelems-- > 0)
#68 if(nelems > 0)
error.h#27print_n_size_t(size_t nelems, const size_t *array);
generate.c#163            size_t nelems = 0; /* # of data list items to generate */
#167            for(;;offset+=nelems) {
#169                nelems=nc_next_iter(&iter,odometerstartvector(odom),odometercountvector(odom));
#170                if(nelems == 0)
#174                for(i=0;i<nelems;i++) {
#189            size_t nelems=nc_next_iter(&iter,odom->start,odom->count);
#190            if(nelems == 0) break;
getvara.c#1225    size_t nelems;
#1289    nelems = 1; /* also Compute the number of elements being retrieved */
#1293 nelems *= edges[i];
#1303    localcopy = (char*)malloc(nelems*externsize);
#1342    for(i=0;i<nelems;i++) {
nc3dispatch.c#472NC3_set_var_chunk_cache(int ncid, int varid, size_t size, size_t nelems, float preemption)
nc3internal.c#173 if(ncp->vars.nelems == 0)
#200 for(ii = 0; ii < ncp->vars.nelems ; ii++, vpp++)
#220          for (; j<ncp->old->vars.nelemsj++) {
#225          if (j < ncp->old->vars.nelems) {
#271 for(ii = 0; ii < ncp->vars.nelemsii++, vpp++)
#290                    for (; j<ncp->old->vars.nelemsj++)
#293                    if (j < ncp->old->vars.nelems) {
#491 for(ii = 0; ii < ncp->vars.nelemsii++, varpp++)
#518 NC_var *const *const end = &vpp[gnu->vars.nelems];
#531 int varid = (int)old->vars.nelems;
#532 for(; varid < (int)gnu->vars.nelemsvarid++)
#558 int varid = (int)old->vars.nelems;
#560 for(; varid < (int)gnu->vars.nelemsvarid++)
#602 for(varid = (int)old->vars.nelems -1; varid >= 0; varid--)
#654 for(varid = (int)old->vars.nelems -1;
#696    if(ncp->vars.nelems == 0)
#714    for (ii = 0; ii < ncp->vars.nelemsii++, vpp++) {
#742 for (ii = 0; ii < ncp->vars.nelemsii++, vpp++) {
#795 if(ncp->vars.nelems != 0)
#847                                         : (ncp->vars.nelems > ncp->old->vars.nelems))
#892 NC_var *const *const end = &vpp[ncp->vars.nelems];
#896 if(ncp->vars.nelems == 0) { /* no non-record variables and
#1348 *ndimsp = (int) nc3->dims.nelems;
#1350 *nvarsp = (int) nc3->vars.nelems;
#1352 *nattsp = (int) nc3->attrs.nelems;
nc3internal.h#90 size_t nelems; /* length of the array */
#130 size_t nelems; /* length of the array */
#138 size_t nelems; /* length of the array */
#151 size_t nelems);
#195 size_t nelems; /* length of the array */
nc4attr.c#952            size_t nelems, const void *valuenc_type memtype)
#954   return nc4_put_att_tc(ncidvaridnamextypememtype, 0, nelemsvalue);
nc4file.c#144nc_set_chunk_cache(size_t size, size_t nelems, float preemption)
#149   nc4_chunk_cache_nelems = nelems;
#172nc_set_chunk_cache_ints(int size, int nelems, int preemption)
#174   if (size <= 0 || nelems <= 0 || preemption < 0 || preemption > 100)
#177   nc4_chunk_cache_nelems = nelems;
nc4var.c#72NC4_set_var_chunk_cache(int ncid, int varid, size_t size, size_t nelems,
#105   var->chunk_cache_nelems = nelems;
#117nc_set_var_chunk_cache_ints(int ncid, int varid, int size, int nelems,
#127   if (nelems >= 0)
#128      real_nelems = nelems;
nccopy.c#183    size_t nelems;
#226    nelems = 1;
#229 nelems += 1 + (ichunksizes[dim] - 1) / ochunksizes[dim];
#233    prod = iprod + oprod * (nelems - 1);
#234    *chunkcache_nelemsp = nelems;
ncgen.h#168        size_t   nelems;   /* size in terms of # of datalist constants
ncgeny.c#3017    sym->typ.nelems = 1;
ncpdispatch.c#1452NCP_set_var_chunk_cache(int ncid, int varid, size_t size, size_t nelems, float preemption)
ncx.c#3674ncx_getn_schar_schar(const void **xpp, size_t nelemsschar *tp)
#3676 (void) memcpy(tp, *xppnelems);
#3677 *xpp = (void *)((schar *)(*xpp) + nelems);
#3682ncx_getn_schar_uchar(const void **xpp, size_t nelemsuchar *tp)
#3684 (void) memcpy(tp, *xppnelems);
#3685 *xpp = (void *)((schar *)(*xpp) + nelems);
#3690ncx_getn_schar_short(const void **xpp, size_t nelems, short *tp)
#3695 while(nelems-- != 0)
#3706ncx_getn_schar_int(const void **xpp, size_t nelems, int *tp)
#3711 while(nelems-- != 0)
#3722ncx_getn_schar_float(const void **xpp, size_t nelems, float *tp)
#3727 while(nelems-- != 0)
#3738ncx_getn_schar_double(const void **xpp, size_t nelems, double *tp)
#3743 while(nelems-- != 0)
#3754ncx_getn_schar_longlong(const void **xpp, size_t nelemslonglong *tp)
#3759 while(nelems-- != 0)
#3770ncx_getn_schar_ushort(const void **xpp, size_t nelemsushort *tp)
#3775 while(nelems-- != 0)
#3786ncx_getn_schar_uint(const void **xpp, size_t nelemsuint *tp)
#3791 while(nelems-- != 0)
#3802ncx_getn_schar_ulonglong(const void **xpp, size_t nelemsulonglong *tp)
#3807 while(nelems-- != 0)
#3819ncx_pad_getn_schar_schar(const void **xpp, size_t nelemsschar *tp)
#3821 size_t rndup = nelems % X_ALIGN;
#3826 (void) memcpy(tp, *xppnelems);
#3827 *xpp = (void *)((char *)(*xpp) + nelems + rndup);
#3833ncx_pad_getn_schar_uchar(const void **xpp, size_t nelemsuchar *tp)
#3835 size_t rndup = nelems % X_ALIGN;
#3840 (void) memcpy(tp, *xppnelems);
#3841 *xpp = (void *)((char *)(*xpp) + nelems + rndup);
#3847ncx_pad_getn_schar_short(const void **xpp, size_t nelems, short *tp)
#3850 size_t rndup = nelems % X_ALIGN;
#3856 while(nelems-- != 0)
#3867ncx_pad_getn_schar_int(const void **xpp, size_t nelems, int *tp)
#3870 size_t rndup = nelems % X_ALIGN;
#3876 while(nelems-- != 0)
#3887ncx_pad_getn_schar_float(const void **xpp, size_t nelems, float *tp)
#3890 size_t rndup = nelems % X_ALIGN;
#3896 while(nelems-- != 0)
#3907ncx_pad_getn_schar_double(const void **xpp, size_t nelems, double *tp)
#3910 size_t rndup = nelems % X_ALIGN;
#3916 while(nelems-- != 0)
#3927ncx_pad_getn_schar_longlong(const void **xpp, size_t nelemslonglong *tp)
#3930 size_t rndup = nelems % X_ALIGN;
#3936 while(nelems-- != 0)
#3947ncx_pad_getn_schar_ushort(const void **xpp, size_t nelemsushort *tp)
#3950 size_t rndup = nelems % X_ALIGN;
#3956 while(nelems-- != 0)
#3967ncx_pad_getn_schar_uint(const void **xpp, size_t nelemsuint *tp)
#3970 size_t rndup = nelems % X_ALIGN;
#3976 while(nelems-- != 0)
#3987ncx_pad_getn_schar_ulonglong(const void **xpp, size_t nelemsulonglong *tp)
#3990 size_t rndup = nelems % X_ALIGN;
#3996 while(nelems-- != 0)
#4008ncx_putn_schar_schar(void **xpp, size_t nelems, const schar *tp)
#4010 (void) memcpy(*xpptpnelems);
#4011 *xpp = (void *)((char *)(*xpp) + nelems);
#4017ncx_putn_schar_uchar(void **xpp, size_t nelems, const uchar *tp)
#4019 (void) memcpy(*xpptpnelems);
#4020 *xpp = (void *)((char *)(*xpp) + nelems);
#4026ncx_putn_schar_short(void **xpp, size_t nelems, const short *tp)
#4031 while(nelems-- != 0)
#4043ncx_putn_schar_int(void **xpp, size_t nelems, const int *tp)
#4048 while(nelems-- != 0)
#4060ncx_putn_schar_float(void **xpp, size_t nelems, const float *tp)
#4065 while(nelems-- != 0)
#4077ncx_putn_schar_double(void **xpp, size_t nelems, const double *tp)
#4082 while(nelems-- != 0)
#4094ncx_putn_schar_longlong(void **xpp, size_t nelems, const longlong *tp)
#4099 while(nelems-- != 0)
#4111ncx_putn_schar_ushort(void **xpp, size_t nelems, const ushort *tp)
#4116 while(nelems-- != 0)
#4128ncx_putn_schar_uint(void **xpp, size_t nelems, const uint *tp)
#4133 while(nelems-- != 0)
#4145ncx_putn_schar_ulonglong(void **xpp, size_t nelems, const ulonglong *tp)
#4150 while(nelems-- != 0)
#4163ncx_pad_putn_schar_schar(void **xpp, size_t nelems, const schar *tp)
#4165 size_t rndup = nelems % X_ALIGN;
#4170 (void) memcpy(*xpptpnelems);
#4171 *xpp = (void *)((char *)(*xpp) + nelems);
#4183ncx_pad_putn_schar_uchar(void **xpp, size_t nelems, const uchar *tp)
#4185 size_t rndup = nelems % X_ALIGN;
#4190 (void) memcpy(*xpptpnelems);
#4191 *xpp = (void *)((char *)(*xpp) + nelems);
#4203ncx_pad_putn_schar_short(void **xpp, size_t nelems, const short *tp)
#4206 size_t rndup = nelems % X_ALIGN;
#4212 while(nelems-- != 0)
#4231ncx_pad_putn_schar_int(void **xpp, size_t nelems, const int *tp)
#4234 size_t rndup = nelems % X_ALIGN;
#4240 while(nelems-- != 0)
#4259ncx_pad_putn_schar_float(void **xpp, size_t nelems, const float *tp)
#4262 size_t rndup = nelems % X_ALIGN;
#4268 while(nelems-- != 0)
#4287ncx_pad_putn_schar_double(void **xpp, size_t nelems, const double *tp)
#4290 size_t rndup = nelems % X_ALIGN;
#4296 while(nelems-- != 0)
#4315ncx_pad_putn_schar_longlong(void **xpp, size_t nelems, const longlong *tp)
#4318 size_t rndup = nelems % X_ALIGN;
#4324 while(nelems-- != 0)
#4343ncx_pad_putn_schar_ushort(void **xpp, size_t nelems, const ushort *tp)
#4346 size_t rndup = nelems % X_ALIGN;
#4352 while(nelems-- != 0)
#4371ncx_pad_putn_schar_uint(void **xpp, size_t nelems, const uint *tp)
#4374 size_t rndup = nelems % X_ALIGN;
#4380 while(nelems-- != 0)
#4399ncx_pad_putn_schar_ulonglong(void **xpp, size_t nelems, const ulonglong *tp)
#4402 size_t rndup = nelems % X_ALIGN;
#4408 while(nelems-- != 0)
#4430ncx_getn_uchar_schar(const void **xpp, size_t nelemsschar *tp)
#4432 (void) memcpy(tp, *xppnelems);
#4433 *xpp = (void *)((schar *)(*xpp) + nelems);
#4438ncx_getn_uchar_uchar(const void **xpp, size_t nelemsuchar *tp)
#4440 (void) memcpy(tp, *xppnelems);
#4441 *xpp = (void *)((schar *)(*xpp) + nelems);
#4446ncx_getn_uchar_short(const void **xpp, size_t nelems, short *tp)
#4451 while(nelems-- != 0)
#4462ncx_getn_uchar_int(const void **xpp, size_t nelems, int *tp)
#4467 while(nelems-- != 0)
#4478ncx_getn_uchar_float(const void **xpp, size_t nelems, float *tp)
#4483 while(nelems-- != 0)
#4494ncx_getn_uchar_double(const void **xpp, size_t nelems, double *tp)
#4499 while(nelems-- != 0)
#4510ncx_getn_uchar_longlong(const void **xpp, size_t nelemslonglong *tp)
#4515 while(nelems-- != 0)
#4526ncx_getn_uchar_ushort(const void **xpp, size_t nelemsushort *tp)
#4531 while(nelems-- != 0)
#4542ncx_getn_uchar_uint(const void **xpp, size_t nelemsuint *tp)
#4547 while(nelems-- != 0)
#4558ncx_getn_uchar_ulonglong(const void **xpp, size_t nelemsulonglong *tp)
#4563 while(nelems-- != 0)
#4575ncx_pad_getn_uchar_schar(const void **xpp, size_t nelemsschar *tp)
#4577 size_t rndup = nelems % X_ALIGN;
#4582 (void) memcpy(tp, *xppnelems);
#4583 *xpp = (void *)((char *)(*xpp) + nelems + rndup);
#4589ncx_pad_getn_uchar_uchar(const void **xpp, size_t nelemsuchar *tp)
#4591 size_t rndup = nelems % X_ALIGN;
#4596 (void) memcpy(tp, *xppnelems);
#4597 *xpp = (void *)((char *)(*xpp) + nelems + rndup);
#4603ncx_pad_getn_uchar_short(const void **xpp, size_t nelems, short *tp)
#4606 size_t rndup = nelems % X_ALIGN;
#4612 while(nelems-- != 0)
#4623ncx_pad_getn_uchar_int(const void **xpp, size_t nelems, int *tp)
#4626 size_t rndup = nelems % X_ALIGN;
#4632 while(nelems-- != 0)
#4643ncx_pad_getn_uchar_float(const void **xpp, size_t nelems, float *tp)
#4646 size_t rndup = nelems % X_ALIGN;
#4652 while(nelems-- != 0)
#4663ncx_pad_getn_uchar_double(const void **xpp, size_t nelems, double *tp)
#4666 size_t rndup = nelems % X_ALIGN;
#4672 while(nelems-- != 0)
#4683ncx_pad_getn_uchar_longlong(const void **xpp, size_t nelemslonglong *tp)
#4686 size_t rndup = nelems % X_ALIGN;
#4692 while(nelems-- != 0)
#4703ncx_pad_getn_uchar_ushort(const void **xpp, size_t nelemsushort *tp)
#4706 size_t rndup = nelems % X_ALIGN;
#4712 while(nelems-- != 0)
#4723ncx_pad_getn_uchar_uint(const void **xpp, size_t nelemsuint *tp)
#4726 size_t rndup = nelems % X_ALIGN;
#4732 while(nelems-- != 0)
#4743ncx_pad_getn_uchar_ulonglong(const void **xpp, size_t nelemsulonglong *tp)
#4746 size_t rndup = nelems % X_ALIGN;
#4752 while(nelems-- != 0)
#4764ncx_putn_uchar_schar(void **xpp, size_t nelems, const schar *tp)
#4766 (void) memcpy(*xpptpnelems);
#4767 *xpp = (void *)((char *)(*xpp) + nelems);
#4773ncx_putn_uchar_uchar(void **xpp, size_t nelems, const uchar *tp)
#4775 (void) memcpy(*xpptpnelems);
#4776 *xpp = (void *)((char *)(*xpp) + nelems);
#4782ncx_putn_uchar_short(void **xpp, size_t nelems, const short *tp)
#4787 while(nelems-- != 0)
#4799ncx_putn_uchar_int(void **xpp, size_t nelems, const int *tp)
#4804 while(nelems-- != 0)
#4816ncx_putn_uchar_float(void **xpp, size_t nelems, const float *tp)
#4821 while(nelems-- != 0)
#4833ncx_putn_uchar_double(void **xpp, size_t nelems, const double *tp)
#4838 while(nelems-- != 0)
#4850ncx_putn_uchar_longlong(void **xpp, size_t nelems, const longlong *tp)
#4855 while(nelems-- != 0)
#4867ncx_putn_uchar_ushort(void **xpp, size_t nelems, const ushort *tp)
#4872 while(nelems-- != 0)
#4884ncx_putn_uchar_uint(void **xpp, size_t nelems, const uint *tp)
#4889 while(nelems-- != 0)
#4901ncx_putn_uchar_ulonglong(void **xpp, size_t nelems, const ulonglong *tp)
#4906 while(nelems-- != 0)
#4919ncx_pad_putn_uchar_schar(void **xpp, size_t nelems, const schar *tp)
#4921 size_t rndup = nelems % X_ALIGN;
#4926 (void) memcpy(*xpptpnelems);
#4927 *xpp = (void *)((char *)(*xpp) + nelems);
#4939ncx_pad_putn_uchar_uchar(void **xpp, size_t nelems, const uchar *tp)
#4941 size_t rndup = nelems % X_ALIGN;
#4946 (void) memcpy(*xpptpnelems);
#4947 *xpp = (void *)((char *)(*xpp) + nelems);
#4959ncx_pad_putn_uchar_short(void **xpp, size_t nelems, const short *tp)
#4962 size_t rndup = nelems % X_ALIGN;
#4968 while(nelems-- != 0)
#4987ncx_pad_putn_uchar_int(void **xpp, size_t nelems, const int *tp)
#4990 size_t rndup = nelems % X_ALIGN;
#4996 while(nelems-- != 0)
#5015ncx_pad_putn_uchar_float(void **xpp, size_t nelems, const float *tp)
#5018 size_t rndup = nelems % X_ALIGN;
#5024 while(nelems-- != 0)
#5043ncx_pad_putn_uchar_double(void **xpp, size_t nelems, const double *tp)
#5046 size_t rndup = nelems % X_ALIGN;
#5052 while(nelems-- != 0)
#5071ncx_pad_putn_uchar_longlong(void **xpp, size_t nelems, const longlong *tp)
#5074 size_t rndup = nelems % X_ALIGN;
#5080 while(nelems-- != 0)
#5099ncx_pad_putn_uchar_ushort(void **xpp, size_t nelems, const ushort *tp)
#5102 size_t rndup = nelems % X_ALIGN;
#5108 while(nelems-- != 0)
#5127ncx_pad_putn_uchar_uint(void **xpp, size_t nelems, const uint *tp)
#5130 size_t rndup = nelems % X_ALIGN;
#5136 while(nelems-- != 0)
#5155ncx_pad_putn_uchar_ulonglong(void **xpp, size_t nelems, const ulonglong *tp)
#5158 size_t rndup = nelems % X_ALIGN;
#5164 while(nelems-- != 0)
#5188ncx_getn_short_short(const void **xpp, size_t nelems, short *tp)
#5191 (void) memcpy(tp, *xppnelems * sizeof(short));
#5193 swapn2b(tp, *xppnelems);
#5195 *xpp = (const void *)((const char *)(*xpp) + nelems * X_SIZEOF_SHORT);
#5200ncx_getn_short_short(const void **xpp, size_t nelems, short *tp)
#5222  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#5223    ni=Min(nelems-j,LOOPCNT);
#5252 for( ; nelems != 0; nelems--, xp += X_SIZEOF_SHORTtp++)
#5266ncx_getn_short_schar(const void **xpp, size_t nelemsschar *tp)
#5288  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#5289    ni=Min(nelems-j,LOOPCNT);
#5318 for( ; nelems != 0; nelems--, xp += X_SIZEOF_SHORTtp++)
#5331ncx_getn_short_int(const void **xpp, size_t nelems, int *tp)
#5353  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#5354    ni=Min(nelems-j,LOOPCNT);
#5383 for( ; nelems != 0; nelems--, xp += X_SIZEOF_SHORTtp++)
#5396ncx_getn_short_float(const void **xpp, size_t nelems, float *tp)
#5418  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#5419    ni=Min(nelems-j,LOOPCNT);
#5448 for( ; nelems != 0; nelems--, xp += X_SIZEOF_SHORTtp++)
#5461ncx_getn_short_double(const void **xpp, size_t nelems, double *tp)
#5483  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#5484    ni=Min(nelems-j,LOOPCNT);
#5513 for( ; nelems != 0; nelems--, xp += X_SIZEOF_SHORTtp++)
#5526ncx_getn_short_longlong(const void **xpp, size_t nelemslonglong *tp)
#5548  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#5549    ni=Min(nelems-j,LOOPCNT);
#5578 for( ; nelems != 0; nelems--, xp += X_SIZEOF_SHORTtp++)
#5591ncx_getn_short_uchar(const void **xpp, size_t nelemsuchar *tp)
#5613  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#5614    ni=Min(nelems-j,LOOPCNT);
#5643 for( ; nelems != 0; nelems--, xp += X_SIZEOF_SHORTtp++)
#5656ncx_getn_short_ushort(const void **xpp, size_t nelemsushort *tp)
#5678  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#5679    ni=Min(nelems-j,LOOPCNT);
#5708 for( ; nelems != 0; nelems--, xp += X_SIZEOF_SHORTtp++)
#5721ncx_getn_short_uint(const void **xpp, size_t nelemsuint *tp)
#5743  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#5744    ni=Min(nelems-j,LOOPCNT);
#5773 for( ; nelems != 0; nelems--, xp += X_SIZEOF_SHORTtp++)
#5786ncx_getn_short_ulonglong(const void **xpp, size_t nelemsulonglong *tp)
#5808  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#5809    ni=Min(nelems-j,LOOPCNT);
#5838 for( ; nelems != 0; nelems--, xp += X_SIZEOF_SHORTtp++)
#5852ncx_pad_getn_short_schar(const void **xpp, size_t nelemsschar *tp)
#5854 const size_t rndup = nelems % 2;
#5859 for( ; nelems != 0; nelems--, xp += X_SIZEOF_SHORTtp++)
#5873ncx_pad_getn_short_uchar(const void **xpp, size_t nelemsuchar *tp)
#5875 const size_t rndup = nelems % 2;
#5880 for( ; nelems != 0; nelems--, xp += X_SIZEOF_SHORTtp++)
#5894ncx_pad_getn_short_short(const void **xpp, size_t nelems, short *tp)
#5896 const size_t rndup = nelems % 2;
#5901 for( ; nelems != 0; nelems--, xp += X_SIZEOF_SHORTtp++)
#5915ncx_pad_getn_short_int(const void **xpp, size_t nelems, int *tp)
#5917 const size_t rndup = nelems % 2;
#5922 for( ; nelems != 0; nelems--, xp += X_SIZEOF_SHORTtp++)
#5936ncx_pad_getn_short_float(const void **xpp, size_t nelems, float *tp)
#5938 const size_t rndup = nelems % 2;
#5943 for( ; nelems != 0; nelems--, xp += X_SIZEOF_SHORTtp++)
#5957ncx_pad_getn_short_double(const void **xpp, size_t nelems, double *tp)
#5959 const size_t rndup = nelems % 2;
#5964 for( ; nelems != 0; nelems--, xp += X_SIZEOF_SHORTtp++)
#5978ncx_pad_getn_short_uint(const void **xpp, size_t nelemsuint *tp)
#5980 const size_t rndup = nelems % 2;
#5985 for( ; nelems != 0; nelems--, xp += X_SIZEOF_SHORTtp++)
#5999ncx_pad_getn_short_longlong(const void **xpp, size_t nelemslonglong *tp)
#6001 const size_t rndup = nelems % 2;
#6006 for( ; nelems != 0; nelems--, xp += X_SIZEOF_SHORTtp++)
#6020ncx_pad_getn_short_ulonglong(const void **xpp, size_t nelemsulonglong *tp)
#6022 const size_t rndup = nelems % 2;
#6027 for( ; nelems != 0; nelems--, xp += X_SIZEOF_SHORTtp++)
#6041ncx_pad_getn_short_ushort(const void **xpp, size_t nelemsushort *tp)
#6043 const size_t rndup = nelems % 2;
#6048 for( ; nelems != 0; nelems--, xp += X_SIZEOF_SHORTtp++)
#6065ncx_putn_short_short(void **xpp, size_t nelems, const short *tp)
#6068 (void) memcpy(*xpptpnelems * X_SIZEOF_SHORT);
#6070 swapn2b(*xpptpnelems);
#6072 *xpp = (void *)((char *)(*xpp) + nelems * X_SIZEOF_SHORT);
#6077ncx_putn_short_short(void **xpp, size_t nelems, const short *tp)
#6099  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#6100    ni=Min(nelems-j,LOOPCNT);
#6134 for( ; nelems != 0; nelems--, xp += X_SIZEOF_SHORTtp++)
#6148ncx_putn_short_schar(void **xpp, size_t nelems, const schar *tp)
#6170  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#6171    ni=Min(nelems-j,LOOPCNT);
#6205 for( ; nelems != 0; nelems--, xp += X_SIZEOF_SHORTtp++)
#6218ncx_putn_short_int(void **xpp, size_t nelems, const int *tp)
#6240  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#6241    ni=Min(nelems-j,LOOPCNT);
#6275 for( ; nelems != 0; nelems--, xp += X_SIZEOF_SHORTtp++)
#6288ncx_putn_short_float(void **xpp, size_t nelems, const float *tp)
#6310  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#6311    ni=Min(nelems-j,LOOPCNT);
#6345 for( ; nelems != 0; nelems--, xp += X_SIZEOF_SHORTtp++)
#6358ncx_putn_short_double(void **xpp, size_t nelems, const double *tp)
#6380  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#6381    ni=Min(nelems-j,LOOPCNT);
#6415 for( ; nelems != 0; nelems--, xp += X_SIZEOF_SHORTtp++)
#6428ncx_putn_short_longlong(void **xpp, size_t nelems, const longlong *tp)
#6450  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#6451    ni=Min(nelems-j,LOOPCNT);
#6485 for( ; nelems != 0; nelems--, xp += X_SIZEOF_SHORTtp++)
#6498ncx_putn_short_uchar(void **xpp, size_t nelems, const uchar *tp)
#6520  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#6521    ni=Min(nelems-j,LOOPCNT);
#6555 for( ; nelems != 0; nelems--, xp += X_SIZEOF_SHORTtp++)
#6568ncx_putn_short_uint(void **xpp, size_t nelems, const uint *tp)
#6590  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#6591    ni=Min(nelems-j,LOOPCNT);
#6625 for( ; nelems != 0; nelems--, xp += X_SIZEOF_SHORTtp++)
#6638ncx_putn_short_ulonglong(void **xpp, size_t nelems, const ulonglong *tp)
#6660  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#6661    ni=Min(nelems-j,LOOPCNT);
#6695 for( ; nelems != 0; nelems--, xp += X_SIZEOF_SHORTtp++)
#6708ncx_putn_short_ushort(void **xpp, size_t nelems, const ushort *tp)
#6730  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#6731    ni=Min(nelems-j,LOOPCNT);
#6765 for( ; nelems != 0; nelems--, xp += X_SIZEOF_SHORTtp++)
#6779ncx_pad_putn_short_schar(void **xpp, size_t nelems, const schar *tp)
#6781 const size_t rndup = nelems % 2;
#6786 for( ; nelems != 0; nelems--, xp += X_SIZEOF_SHORTtp++)
#6804ncx_pad_putn_short_uchar(void **xpp, size_t nelems, const uchar *tp)
#6806 const size_t rndup = nelems % 2;
#6811 for( ; nelems != 0; nelems--, xp += X_SIZEOF_SHORTtp++)
#6829ncx_pad_putn_short_short(void **xpp, size_t nelems, const short *tp)
#6831 const size_t rndup = nelems % 2;
#6836 for( ; nelems != 0; nelems--, xp += X_SIZEOF_SHORTtp++)
#6854ncx_pad_putn_short_int(void **xpp, size_t nelems, const int *tp)
#6856 const size_t rndup = nelems % 2;
#6861 for( ; nelems != 0; nelems--, xp += X_SIZEOF_SHORTtp++)
#6879ncx_pad_putn_short_float(void **xpp, size_t nelems, const float *tp)
#6881 const size_t rndup = nelems % 2;
#6886 for( ; nelems != 0; nelems--, xp += X_SIZEOF_SHORTtp++)
#6904ncx_pad_putn_short_double(void **xpp, size_t nelems, const double *tp)
#6906 const size_t rndup = nelems % 2;
#6911 for( ; nelems != 0; nelems--, xp += X_SIZEOF_SHORTtp++)
#6929ncx_pad_putn_short_uint(void **xpp, size_t nelems, const uint *tp)
#6931 const size_t rndup = nelems % 2;
#6936 for( ; nelems != 0; nelems--, xp += X_SIZEOF_SHORTtp++)
#6954ncx_pad_putn_short_longlong(void **xpp, size_t nelems, const longlong *tp)
#6956 const size_t rndup = nelems % 2;
#6961 for( ; nelems != 0; nelems--, xp += X_SIZEOF_SHORTtp++)
#6979ncx_pad_putn_short_ulonglong(void **xpp, size_t nelems, const ulonglong *tp)
#6981 const size_t rndup = nelems % 2;
#6986 for( ; nelems != 0; nelems--, xp += X_SIZEOF_SHORTtp++)
#7004ncx_pad_putn_short_ushort(void **xpp, size_t nelems, const ushort *tp)
#7006 const size_t rndup = nelems % 2;
#7011 for( ; nelems != 0; nelems--, xp += X_SIZEOF_SHORTtp++)
#7035ncx_getn_ushort_ushort(const void **xpp, size_t nelems, unsigned short *tp)
#7038 (void) memcpy(tp, *xppnelems * sizeof(unsigned short));
#7040 swapn2b(tp, *xppnelems);
#7042 *xpp = (const void *)((const char *)(*xpp) + nelems * X_SIZEOF_USHORT);
#7047ncx_getn_ushort_ushort(const void **xpp, size_t nelemsushort *tp)
#7069  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#7070    ni=Min(nelems-j,LOOPCNT);
#7099 for( ; nelems != 0; nelems--, xp += X_SIZEOF_USHORTtp++)
#7113ncx_getn_ushort_schar(const void **xpp, size_t nelemsschar *tp)
#7135  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#7136    ni=Min(nelems-j,LOOPCNT);
#7165 for( ; nelems != 0; nelems--, xp += X_SIZEOF_USHORTtp++)
#7178ncx_getn_ushort_short(const void **xpp, size_t nelems, short *tp)
#7200  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#7201    ni=Min(nelems-j,LOOPCNT);
#7230 for( ; nelems != 0; nelems--, xp += X_SIZEOF_USHORTtp++)
#7243ncx_getn_ushort_int(const void **xpp, size_t nelems, int *tp)
#7265  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#7266    ni=Min(nelems-j,LOOPCNT);
#7295 for( ; nelems != 0; nelems--, xp += X_SIZEOF_USHORTtp++)
#7308ncx_getn_ushort_float(const void **xpp, size_t nelems, float *tp)
#7330  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#7331    ni=Min(nelems-j,LOOPCNT);
#7360 for( ; nelems != 0; nelems--, xp += X_SIZEOF_USHORTtp++)
#7373ncx_getn_ushort_double(const void **xpp, size_t nelems, double *tp)
#7395  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#7396    ni=Min(nelems-j,LOOPCNT);
#7425 for( ; nelems != 0; nelems--, xp += X_SIZEOF_USHORTtp++)
#7438ncx_getn_ushort_longlong(const void **xpp, size_t nelemslonglong *tp)
#7460  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#7461    ni=Min(nelems-j,LOOPCNT);
#7490 for( ; nelems != 0; nelems--, xp += X_SIZEOF_USHORTtp++)
#7503ncx_getn_ushort_uchar(const void **xpp, size_t nelemsuchar *tp)
#7525  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#7526    ni=Min(nelems-j,LOOPCNT);
#7555 for( ; nelems != 0; nelems--, xp += X_SIZEOF_USHORTtp++)
#7568ncx_getn_ushort_uint(const void **xpp, size_t nelemsuint *tp)
#7590  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#7591    ni=Min(nelems-j,LOOPCNT);
#7620 for( ; nelems != 0; nelems--, xp += X_SIZEOF_USHORTtp++)
#7633ncx_getn_ushort_ulonglong(const void **xpp, size_t nelemsulonglong *tp)
#7655  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#7656    ni=Min(nelems-j,LOOPCNT);
#7685 for( ; nelems != 0; nelems--, xp += X_SIZEOF_USHORTtp++)
#7699ncx_pad_getn_ushort_schar(const void **xpp, size_t nelemsschar *tp)
#7701 const size_t rndup = nelems % 2;
#7706 for( ; nelems != 0; nelems--, xp += X_SIZEOF_USHORTtp++)
#7720ncx_pad_getn_ushort_uchar(const void **xpp, size_t nelemsuchar *tp)
#7722 const size_t rndup = nelems % 2;
#7727 for( ; nelems != 0; nelems--, xp += X_SIZEOF_USHORTtp++)
#7741ncx_pad_getn_ushort_short(const void **xpp, size_t nelems, short *tp)
#7743 const size_t rndup = nelems % 2;
#7748 for( ; nelems != 0; nelems--, xp += X_SIZEOF_USHORTtp++)
#7762ncx_pad_getn_ushort_ushort(const void **xpp, size_t nelemsushort *tp)
#7764 const size_t rndup = nelems % 2;
#7769 for( ; nelems != 0; nelems--, xp += X_SIZEOF_USHORTtp++)
#7783ncx_pad_getn_ushort_int(const void **xpp, size_t nelems, int *tp)
#7785 const size_t rndup = nelems % 2;
#7790 for( ; nelems != 0; nelems--, xp += X_SIZEOF_USHORTtp++)
#7804ncx_pad_getn_ushort_uint(const void **xpp, size_t nelemsuint *tp)
#7806 const size_t rndup = nelems % 2;
#7811 for( ; nelems != 0; nelems--, xp += X_SIZEOF_USHORTtp++)
#7825ncx_pad_getn_ushort_float(const void **xpp, size_t nelems, float *tp)
#7827 const size_t rndup = nelems % 2;
#7832 for( ; nelems != 0; nelems--, xp += X_SIZEOF_USHORTtp++)
#7846ncx_pad_getn_ushort_double(const void **xpp, size_t nelems, double *tp)
#7848 const size_t rndup = nelems % 2;
#7853 for( ; nelems != 0; nelems--, xp += X_SIZEOF_USHORTtp++)
#7867ncx_pad_getn_ushort_longlong(const void **xpp, size_t nelemslonglong *tp)
#7869 const size_t rndup = nelems % 2;
#7874 for( ; nelems != 0; nelems--, xp += X_SIZEOF_USHORTtp++)
#7888ncx_pad_getn_ushort_ulonglong(const void **xpp, size_t nelemsulonglong *tp)
#7890 const size_t rndup = nelems % 2;
#7895 for( ; nelems != 0; nelems--, xp += X_SIZEOF_USHORTtp++)
#7912ncx_putn_ushort_ushort(void **xpp, size_t nelems, const unsigned short *tp)
#7915 (void) memcpy(*xpptpnelems * X_SIZEOF_USHORT);
#7917 swapn2b(*xpptpnelems);
#7919 *xpp = (void *)((char *)(*xpp) + nelems * X_SIZEOF_USHORT);
#7924ncx_putn_ushort_ushort(void **xpp, size_t nelems, const ushort *tp)
#7946  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#7947    ni=Min(nelems-j,LOOPCNT);
#7981 for( ; nelems != 0; nelems--, xp += X_SIZEOF_USHORTtp++)
#7995ncx_putn_ushort_schar(void **xpp, size_t nelems, const schar *tp)
#8017  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#8018    ni=Min(nelems-j,LOOPCNT);
#8052 for( ; nelems != 0; nelems--, xp += X_SIZEOF_USHORTtp++)
#8065ncx_putn_ushort_short(void **xpp, size_t nelems, const short *tp)
#8087  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#8088    ni=Min(nelems-j,LOOPCNT);
#8122 for( ; nelems != 0; nelems--, xp += X_SIZEOF_USHORTtp++)
#8135ncx_putn_ushort_int(void **xpp, size_t nelems, const int *tp)
#8157  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#8158    ni=Min(nelems-j,LOOPCNT);
#8192 for( ; nelems != 0; nelems--, xp += X_SIZEOF_USHORTtp++)
#8205ncx_putn_ushort_float(void **xpp, size_t nelems, const float *tp)
#8227  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#8228    ni=Min(nelems-j,LOOPCNT);
#8262 for( ; nelems != 0; nelems--, xp += X_SIZEOF_USHORTtp++)
#8275ncx_putn_ushort_double(void **xpp, size_t nelems, const double *tp)
#8297  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#8298    ni=Min(nelems-j,LOOPCNT);
#8332 for( ; nelems != 0; nelems--, xp += X_SIZEOF_USHORTtp++)
#8345ncx_putn_ushort_longlong(void **xpp, size_t nelems, const longlong *tp)
#8367  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#8368    ni=Min(nelems-j,LOOPCNT);
#8402 for( ; nelems != 0; nelems--, xp += X_SIZEOF_USHORTtp++)
#8415ncx_putn_ushort_uchar(void **xpp, size_t nelems, const uchar *tp)
#8437  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#8438    ni=Min(nelems-j,LOOPCNT);
#8472 for( ; nelems != 0; nelems--, xp += X_SIZEOF_USHORTtp++)
#8485ncx_putn_ushort_uint(void **xpp, size_t nelems, const uint *tp)
#8507  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#8508    ni=Min(nelems-j,LOOPCNT);
#8542 for( ; nelems != 0; nelems--, xp += X_SIZEOF_USHORTtp++)
#8555ncx_putn_ushort_ulonglong(void **xpp, size_t nelems, const ulonglong *tp)
#8577  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#8578    ni=Min(nelems-j,LOOPCNT);
#8612 for( ; nelems != 0; nelems--, xp += X_SIZEOF_USHORTtp++)
#8626ncx_pad_putn_ushort_schar(void **xpp, size_t nelems, const schar *tp)
#8628 const size_t rndup = nelems % 2;
#8633 for( ; nelems != 0; nelems--, xp += X_SIZEOF_USHORTtp++)
#8651ncx_pad_putn_ushort_uchar(void **xpp, size_t nelems, const uchar *tp)
#8653 const size_t rndup = nelems % 2;
#8658 for( ; nelems != 0; nelems--, xp += X_SIZEOF_USHORTtp++)
#8676ncx_pad_putn_ushort_short(void **xpp, size_t nelems, const short *tp)
#8678 const size_t rndup = nelems % 2;
#8683 for( ; nelems != 0; nelems--, xp += X_SIZEOF_USHORTtp++)
#8701ncx_pad_putn_ushort_int(void **xpp, size_t nelems, const int *tp)
#8703 const size_t rndup = nelems % 2;
#8708 for( ; nelems != 0; nelems--, xp += X_SIZEOF_USHORTtp++)
#8726ncx_pad_putn_ushort_float(void **xpp, size_t nelems, const float *tp)
#8728 const size_t rndup = nelems % 2;
#8733 for( ; nelems != 0; nelems--, xp += X_SIZEOF_USHORTtp++)
#8751ncx_pad_putn_ushort_double(void **xpp, size_t nelems, const double *tp)
#8753 const size_t rndup = nelems % 2;
#8758 for( ; nelems != 0; nelems--, xp += X_SIZEOF_USHORTtp++)
#8776ncx_pad_putn_ushort_uint(void **xpp, size_t nelems, const uint *tp)
#8778 const size_t rndup = nelems % 2;
#8783 for( ; nelems != 0; nelems--, xp += X_SIZEOF_USHORTtp++)
#8801ncx_pad_putn_ushort_longlong(void **xpp, size_t nelems, const longlong *tp)
#8803 const size_t rndup = nelems % 2;
#8808 for( ; nelems != 0; nelems--, xp += X_SIZEOF_USHORTtp++)
#8826ncx_pad_putn_ushort_ulonglong(void **xpp, size_t nelems, const ulonglong *tp)
#8828 const size_t rndup = nelems % 2;
#8833 for( ; nelems != 0; nelems--, xp += X_SIZEOF_USHORTtp++)
#8851ncx_pad_putn_ushort_ushort(void **xpp, size_t nelems, const ushort *tp)
#8853 const size_t rndup = nelems % 2;
#8858 for( ; nelems != 0; nelems--, xp += X_SIZEOF_USHORTtp++)
#8882ncx_getn_int_int(const void **xpp, size_t nelems, int *tp)
#8885 (void) memcpy(tp, *xppnelems * sizeof(int));
#8887 swapn4b(tp, *xppnelems);
#8889 *xpp = (const void *)((const char *)(*xpp) + nelems * X_SIZEOF_INT);
#8894ncx_getn_int_int(const void **xpp, size_t nelems, int *tp)
#8916  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#8917    ni=Min(nelems-j,LOOPCNT);
#8946 for( ; nelems != 0; nelems--, xp += X_SIZEOF_INTtp++)
#8960ncx_getn_int_schar(const void **xpp, size_t nelemsschar *tp)
#8982  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#8983    ni=Min(nelems-j,LOOPCNT);
#9012 for( ; nelems != 0; nelems--, xp += X_SIZEOF_INTtp++)
#9025ncx_getn_int_short(const void **xpp, size_t nelems, short *tp)
#9047  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#9048    ni=Min(nelems-j,LOOPCNT);
#9077 for( ; nelems != 0; nelems--, xp += X_SIZEOF_INTtp++)
#9090ncx_getn_int_float(const void **xpp, size_t nelems, float *tp)
#9112  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#9113    ni=Min(nelems-j,LOOPCNT);
#9142 for( ; nelems != 0; nelems--, xp += X_SIZEOF_INTtp++)
#9155ncx_getn_int_double(const void **xpp, size_t nelems, double *tp)
#9177  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#9178    ni=Min(nelems-j,LOOPCNT);
#9207 for( ; nelems != 0; nelems--, xp += X_SIZEOF_INTtp++)
#9220ncx_getn_int_longlong(const void **xpp, size_t nelemslonglong *tp)
#9242  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#9243    ni=Min(nelems-j,LOOPCNT);
#9272 for( ; nelems != 0; nelems--, xp += X_SIZEOF_INTtp++)
#9285ncx_getn_int_uchar(const void **xpp, size_t nelemsuchar *tp)
#9307  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#9308    ni=Min(nelems-j,LOOPCNT);
#9337 for( ; nelems != 0; nelems--, xp += X_SIZEOF_INTtp++)
#9350ncx_getn_int_ushort(const void **xpp, size_t nelemsushort *tp)
#9372  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#9373    ni=Min(nelems-j,LOOPCNT);
#9402 for( ; nelems != 0; nelems--, xp += X_SIZEOF_INTtp++)
#9415ncx_getn_int_uint(const void **xpp, size_t nelemsuint *tp)
#9437  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#9438    ni=Min(nelems-j,LOOPCNT);
#9467 for( ; nelems != 0; nelems--, xp += X_SIZEOF_INTtp++)
#9480ncx_getn_int_ulonglong(const void **xpp, size_t nelemsulonglong *tp)
#9502  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#9503    ni=Min(nelems-j,LOOPCNT);
#9532 for( ; nelems != 0; nelems--, xp += X_SIZEOF_INTtp++)
#9548ncx_putn_int_int(void **xpp, size_t nelems, const int *tp)
#9551 (void) memcpy(*xpptpnelems * X_SIZEOF_INT);
#9553 swapn4b(*xpptpnelems);
#9555 *xpp = (void *)((char *)(*xpp) + nelems * X_SIZEOF_INT);
#9560ncx_putn_int_int(void **xpp, size_t nelems, const int *tp)
#9582  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#9583    ni=Min(nelems-j,LOOPCNT);
#9617 for( ; nelems != 0; nelems--, xp += X_SIZEOF_INTtp++)
#9631ncx_putn_int_schar(void **xpp, size_t nelems, const schar *tp)
#9653  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#9654    ni=Min(nelems-j,LOOPCNT);
#9688 for( ; nelems != 0; nelems--, xp += X_SIZEOF_INTtp++)
#9701ncx_putn_int_short(void **xpp, size_t nelems, const short *tp)
#9723  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#9724    ni=Min(nelems-j,LOOPCNT);
#9758 for( ; nelems != 0; nelems--, xp += X_SIZEOF_INTtp++)
#9771ncx_putn_int_float(void **xpp, size_t nelems, const float *tp)
#9794  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#9795    ni=Min(nelems-j,LOOPCNT);
#9827 for( ; nelems != 0; nelems--, xp += X_SIZEOF_INTtp++)
#9840ncx_putn_int_double(void **xpp, size_t nelems, const double *tp)
#9862  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#9863    ni=Min(nelems-j,LOOPCNT);
#9897 for( ; nelems != 0; nelems--, xp += X_SIZEOF_INTtp++)
#9910ncx_putn_int_longlong(void **xpp, size_t nelems, const longlong *tp)
#9932  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#9933    ni=Min(nelems-j,LOOPCNT);
#9967 for( ; nelems != 0; nelems--, xp += X_SIZEOF_INTtp++)
#9980ncx_putn_int_uchar(void **xpp, size_t nelems, const uchar *tp)
#10002  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#10003    ni=Min(nelems-j,LOOPCNT);
#10037 for( ; nelems != 0; nelems--, xp += X_SIZEOF_INTtp++)
#10050ncx_putn_int_ushort(void **xpp, size_t nelems, const ushort *tp)
#10072  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#10073    ni=Min(nelems-j,LOOPCNT);
#10107 for( ; nelems != 0; nelems--, xp += X_SIZEOF_INTtp++)
#10120ncx_putn_int_uint(void **xpp, size_t nelems, const uint *tp)
#10142  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#10143    ni=Min(nelems-j,LOOPCNT);
#10177 for( ; nelems != 0; nelems--, xp += X_SIZEOF_INTtp++)
#10190ncx_putn_int_ulonglong(void **xpp, size_t nelems, const ulonglong *tp)
#10212  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#10213    ni=Min(nelems-j,LOOPCNT);
#10247 for( ; nelems != 0; nelems--, xp += X_SIZEOF_INTtp++)
#10265ncx_getn_uint_uint(const void **xpp, size_t nelems, unsigned int *tp)
#10268 (void) memcpy(tp, *xppnelems * sizeof(uint));
#10270 swapn4b(tp, *xppnelems);
#10272 *xpp = (const void *)((const char *)(*xpp) + nelems * X_SIZEOF_UINT);
#10277ncx_getn_uint_uint(const void **xpp, size_t nelemsuint *tp)
#10299  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#10300    ni=Min(nelems-j,LOOPCNT);
#10329 for( ; nelems != 0; nelems--, xp += X_SIZEOF_UINTtp++)
#10343ncx_getn_uint_schar(const void **xpp, size_t nelemsschar *tp)
#10365  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#10366    ni=Min(nelems-j,LOOPCNT);
#10395 for( ; nelems != 0; nelems--, xp += X_SIZEOF_UINTtp++)
#10408ncx_getn_uint_short(const void **xpp, size_t nelems, short *tp)
#10430  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#10431    ni=Min(nelems-j,LOOPCNT);
#10460 for( ; nelems != 0; nelems--, xp += X_SIZEOF_UINTtp++)
#10473ncx_getn_uint_int(const void **xpp, size_t nelems, int *tp)
#10495  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#10496    ni=Min(nelems-j,LOOPCNT);
#10525 for( ; nelems != 0; nelems--, xp += X_SIZEOF_UINTtp++)
#10538ncx_getn_uint_float(const void **xpp, size_t nelems, float *tp)
#10560  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#10561    ni=Min(nelems-j,LOOPCNT);
#10590 for( ; nelems != 0; nelems--, xp += X_SIZEOF_UINTtp++)
#10603ncx_getn_uint_double(const void **xpp, size_t nelems, double *tp)
#10625  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#10626    ni=Min(nelems-j,LOOPCNT);
#10655 for( ; nelems != 0; nelems--, xp += X_SIZEOF_UINTtp++)
#10668ncx_getn_uint_longlong(const void **xpp, size_t nelemslonglong *tp)
#10690  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#10691    ni=Min(nelems-j,LOOPCNT);
#10720 for( ; nelems != 0; nelems--, xp += X_SIZEOF_UINTtp++)
#10733ncx_getn_uint_uchar(const void **xpp, size_t nelemsuchar *tp)
#10755  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#10756    ni=Min(nelems-j,LOOPCNT);
#10785 for( ; nelems != 0; nelems--, xp += X_SIZEOF_UINTtp++)
#10798ncx_getn_uint_ushort(const void **xpp, size_t nelemsushort *tp)
#10820  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#10821    ni=Min(nelems-j,LOOPCNT);
#10850 for( ; nelems != 0; nelems--, xp += X_SIZEOF_UINTtp++)
#10863ncx_getn_uint_ulonglong(const void **xpp, size_t nelemsulonglong *tp)
#10885  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#10886    ni=Min(nelems-j,LOOPCNT);
#10915 for( ; nelems != 0; nelems--, xp += X_SIZEOF_UINTtp++)
#10931ncx_putn_uint_uint(void **xpp, size_t nelems, const unsigned int *tp)
#10934 (void) memcpy(*xpptpnelems * X_SIZEOF_UINT);
#10936 swapn4b(*xpptpnelems);
#10938 *xpp = (void *)((char *)(*xpp) + nelems * X_SIZEOF_UINT);
#10943ncx_putn_uint_uint(void **xpp, size_t nelems, const uint *tp)
#10965  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#10966    ni=Min(nelems-j,LOOPCNT);
#11000 for( ; nelems != 0; nelems--, xp += X_SIZEOF_UINTtp++)
#11014ncx_putn_uint_schar(void **xpp, size_t nelems, const schar *tp)
#11036  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#11037    ni=Min(nelems-j,LOOPCNT);
#11071 for( ; nelems != 0; nelems--, xp += X_SIZEOF_UINTtp++)
#11084ncx_putn_uint_short(void **xpp, size_t nelems, const short *tp)
#11106  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#11107    ni=Min(nelems-j,LOOPCNT);
#11141 for( ; nelems != 0; nelems--, xp += X_SIZEOF_UINTtp++)
#11154ncx_putn_uint_int(void **xpp, size_t nelems, const int *tp)
#11176  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#11177    ni=Min(nelems-j,LOOPCNT);
#11211 for( ; nelems != 0; nelems--, xp += X_SIZEOF_UINTtp++)
#11224ncx_putn_uint_float(void **xpp, size_t nelems, const float *tp)
#11246  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#11247    ni=Min(nelems-j,LOOPCNT);
#11281 for( ; nelems != 0; nelems--, xp += X_SIZEOF_UINTtp++)
#11294ncx_putn_uint_double(void **xpp, size_t nelems, const double *tp)
#11316  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#11317    ni=Min(nelems-j,LOOPCNT);
#11351 for( ; nelems != 0; nelems--, xp += X_SIZEOF_UINTtp++)
#11364ncx_putn_uint_longlong(void **xpp, size_t nelems, const longlong *tp)
#11386  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#11387    ni=Min(nelems-j,LOOPCNT);
#11421 for( ; nelems != 0; nelems--, xp += X_SIZEOF_UINTtp++)
#11434ncx_putn_uint_uchar(void **xpp, size_t nelems, const uchar *tp)
#11456  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#11457    ni=Min(nelems-j,LOOPCNT);
#11491 for( ; nelems != 0; nelems--, xp += X_SIZEOF_UINTtp++)
#11504ncx_putn_uint_ushort(void **xpp, size_t nelems, const ushort *tp)
#11526  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#11527    ni=Min(nelems-j,LOOPCNT);
#11561 for( ; nelems != 0; nelems--, xp += X_SIZEOF_UINTtp++)
#11574ncx_putn_uint_ulonglong(void **xpp, size_t nelems, const ulonglong *tp)
#11596  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#11597    ni=Min(nelems-j,LOOPCNT);
#11631 for( ; nelems != 0; nelems--, xp += X_SIZEOF_UINTtp++)
#11650ncx_getn_float_float(const void **xpp, size_t nelems, float *tp)
#11653 (void) memcpy(tp, *xppnelems * sizeof(float));
#11655 swapn4b(tp, *xppnelems);
#11657 *xpp = (const void *)((const char *)(*xpp) + nelems * X_SIZEOF_FLOAT);
#11722ncx_getn_float_float(const void **xpp, size_t nelems, float *tp)
#11727 for( ; nelems != 0; nelems--, xp += X_SIZEOF_FLOATtp++)
#11740ncx_getn_float_schar(const void **xpp, size_t nelemsschar *tp)
#11762  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#11763    ni=Min(nelems-j,LOOPCNT);
#11792 for( ; nelems != 0; nelems--, xp += X_SIZEOF_FLOATtp++)
#11805ncx_getn_float_short(const void **xpp, size_t nelems, short *tp)
#11827  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#11828    ni=Min(nelems-j,LOOPCNT);
#11857 for( ; nelems != 0; nelems--, xp += X_SIZEOF_FLOATtp++)
#11870ncx_getn_float_int(const void **xpp, size_t nelems, int *tp)
#11892  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#11893    ni=Min(nelems-j,LOOPCNT);
#11922 for( ; nelems != 0; nelems--, xp += X_SIZEOF_FLOATtp++)
#11935ncx_getn_float_double(const void **xpp, size_t nelems, double *tp)
#11957  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#11958    ni=Min(nelems-j,LOOPCNT);
#11987 for( ; nelems != 0; nelems--, xp += X_SIZEOF_FLOATtp++)
#12000ncx_getn_float_longlong(const void **xpp, size_t nelemslonglong *tp)
#12022  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#12023    ni=Min(nelems-j,LOOPCNT);
#12052 for( ; nelems != 0; nelems--, xp += X_SIZEOF_FLOATtp++)
#12065ncx_getn_float_ushort(const void **xpp, size_t nelemsushort *tp)
#12087  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#12088    ni=Min(nelems-j,LOOPCNT);
#12117 for( ; nelems != 0; nelems--, xp += X_SIZEOF_FLOATtp++)
#12130ncx_getn_float_uchar(const void **xpp, size_t nelemsuchar *tp)
#12152  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#12153    ni=Min(nelems-j,LOOPCNT);
#12182 for( ; nelems != 0; nelems--, xp += X_SIZEOF_FLOATtp++)
#12195ncx_getn_float_uint(const void **xpp, size_t nelemsuint *tp)
#12217  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#12218    ni=Min(nelems-j,LOOPCNT);
#12247 for( ; nelems != 0; nelems--, xp += X_SIZEOF_FLOATtp++)
#12260ncx_getn_float_ulonglong(const void **xpp, size_t nelemsulonglong *tp)
#12282  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#12283    ni=Min(nelems-j,LOOPCNT);
#12312 for( ; nelems != 0; nelems--, xp += X_SIZEOF_FLOATtp++)
#12328ncx_putn_float_float(void **xpp, size_t nelems, const float *tp)
#12331 (void) memcpy(*xpptpnelems * X_SIZEOF_FLOAT);
#12333 swapn4b(*xpptpnelems);
#12335 *xpp = (void *)((char *)(*xpp) + nelems * X_SIZEOF_FLOAT);
#12399ncx_putn_float_float(void **xpp, size_t nelems, const float *tp)
#12404 for( ; nelems != 0; nelems--, xp += X_SIZEOF_FLOATtp++)
#12416ncx_putn_float_schar(void **xpp, size_t nelems, const schar *tp)
#12438  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#12439    ni=Min(nelems-j,LOOPCNT);
#12473 for( ; nelems != 0; nelems--, xp += X_SIZEOF_FLOATtp++)
#12486ncx_putn_float_short(void **xpp, size_t nelems, const short *tp)
#12508  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#12509    ni=Min(nelems-j,LOOPCNT);
#12543 for( ; nelems != 0; nelems--, xp += X_SIZEOF_FLOATtp++)
#12556ncx_putn_float_int(void **xpp, size_t nelems, const int *tp)
#12578  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#12579    ni=Min(nelems-j,LOOPCNT);
#12613 for( ; nelems != 0; nelems--, xp += X_SIZEOF_FLOATtp++)
#12626ncx_putn_float_double(void **xpp, size_t nelems, const double *tp)
#12648  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#12649    ni=Min(nelems-j,LOOPCNT);
#12683 for( ; nelems != 0; nelems--, xp += X_SIZEOF_FLOATtp++)
#12696ncx_putn_float_longlong(void **xpp, size_t nelems, const longlong *tp)
#12718  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#12719    ni=Min(nelems-j,LOOPCNT);
#12753 for( ; nelems != 0; nelems--, xp += X_SIZEOF_FLOATtp++)
#12766ncx_putn_float_uchar(void **xpp, size_t nelems, const uchar *tp)
#12788  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#12789    ni=Min(nelems-j,LOOPCNT);
#12823 for( ; nelems != 0; nelems--, xp += X_SIZEOF_FLOATtp++)
#12836ncx_putn_float_ushort(void **xpp, size_t nelems, const ushort *tp)
#12858  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#12859    ni=Min(nelems-j,LOOPCNT);
#12893 for( ; nelems != 0; nelems--, xp += X_SIZEOF_FLOATtp++)
#12906ncx_putn_float_uint(void **xpp, size_t nelems, const uint *tp)
#12928  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#12929    ni=Min(nelems-j,LOOPCNT);
#12963 for( ; nelems != 0; nelems--, xp += X_SIZEOF_FLOATtp++)
#12976ncx_putn_float_ulonglong(void **xpp, size_t nelems, const ulonglong *tp)
#12998  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#12999    ni=Min(nelems-j,LOOPCNT);
#13033 for( ; nelems != 0; nelems--, xp += X_SIZEOF_FLOATtp++)
#13051ncx_getn_double_double(const void **xpp, size_t nelems, double *tp)
#13054 (void) memcpy(tp, *xppnelems * sizeof(double));
#13056 swapn8b(tp, *xppnelems);
#13058 *xpp = (const void *)((const char *)(*xpp) + nelems * X_SIZEOF_DOUBLE);
#13119ncx_getn_double_double(const void **xpp, size_t nelems, double *tp)
#13124 for( ; nelems != 0; nelems--, xp += X_SIZEOF_DOUBLEtp++)
#13136ncx_getn_double_schar(const void **xpp, size_t nelemsschar *tp)
#13158  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#13159    ni=Min(nelems-j,LOOPCNT);
#13188 for( ; nelems != 0; nelems--, xp += X_SIZEOF_DOUBLEtp++)
#13201ncx_getn_double_short(const void **xpp, size_t nelems, short *tp)
#13223  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#13224    ni=Min(nelems-j,LOOPCNT);
#13253 for( ; nelems != 0; nelems--, xp += X_SIZEOF_DOUBLEtp++)
#13266ncx_getn_double_int(const void **xpp, size_t nelems, int *tp)
#13288  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#13289    ni=Min(nelems-j,LOOPCNT);
#13318 for( ; nelems != 0; nelems--, xp += X_SIZEOF_DOUBLEtp++)
#13331ncx_getn_double_float(const void **xpp, size_t nelems, float *tp)
#13353  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#13354    ni=Min(nelems-j,LOOPCNT);
#13383 for( ; nelems != 0; nelems--, xp += X_SIZEOF_DOUBLEtp++)
#13396ncx_getn_double_longlong(const void **xpp, size_t nelemslonglong *tp)
#13418  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#13419    ni=Min(nelems-j,LOOPCNT);
#13448 for( ; nelems != 0; nelems--, xp += X_SIZEOF_DOUBLEtp++)
#13461ncx_getn_double_uchar(const void **xpp, size_t nelemsuchar *tp)
#13483  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#13484    ni=Min(nelems-j,LOOPCNT);
#13513 for( ; nelems != 0; nelems--, xp += X_SIZEOF_DOUBLEtp++)
#13526ncx_getn_double_ushort(const void **xpp, size_t nelemsushort *tp)
#13548  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#13549    ni=Min(nelems-j,LOOPCNT);
#13578 for( ; nelems != 0; nelems--, xp += X_SIZEOF_DOUBLEtp++)
#13591ncx_getn_double_uint(const void **xpp, size_t nelemsuint *tp)
#13613  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#13614    ni=Min(nelems-j,LOOPCNT);
#13643 for( ; nelems != 0; nelems--, xp += X_SIZEOF_DOUBLEtp++)
#13656ncx_getn_double_ulonglong(const void **xpp, size_t nelemsulonglong *tp)
#13678  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#13679    ni=Min(nelems-j,LOOPCNT);
#13708 for( ; nelems != 0; nelems--, xp += X_SIZEOF_DOUBLEtp++)
#13724ncx_putn_double_double(void **xpp, size_t nelems, const double *tp)
#13727 (void) memcpy(*xpptpnelems * X_SIZEOF_DOUBLE);
#13729 swapn8b(*xpptpnelems);
#13731 *xpp = (void *)((char *)(*xpp) + nelems * X_SIZEOF_DOUBLE);
#13810ncx_putn_double_double(void **xpp, size_t nelems, const double *tp)
#13815 for( ; nelems != 0; nelems--, xp += X_SIZEOF_DOUBLEtp++)
#13827ncx_putn_double_schar(void **xpp, size_t nelems, const schar *tp)
#13849  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#13850    ni=Min(nelems-j,LOOPCNT);
#13884 for( ; nelems != 0; nelems--, xp += X_SIZEOF_DOUBLEtp++)
#13897ncx_putn_double_short(void **xpp, size_t nelems, const short *tp)
#13919  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#13920    ni=Min(nelems-j,LOOPCNT);
#13954 for( ; nelems != 0; nelems--, xp += X_SIZEOF_DOUBLEtp++)
#13967ncx_putn_double_int(void **xpp, size_t nelems, const int *tp)
#13989  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#13990    ni=Min(nelems-j,LOOPCNT);
#14024 for( ; nelems != 0; nelems--, xp += X_SIZEOF_DOUBLEtp++)
#14037ncx_putn_double_float(void **xpp, size_t nelems, const float *tp)
#14059  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#14060    ni=Min(nelems-j,LOOPCNT);
#14094 for( ; nelems != 0; nelems--, xp += X_SIZEOF_DOUBLEtp++)
#14107ncx_putn_double_longlong(void **xpp, size_t nelems, const longlong *tp)
#14129  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#14130    ni=Min(nelems-j,LOOPCNT);
#14164 for( ; nelems != 0; nelems--, xp += X_SIZEOF_DOUBLEtp++)
#14177ncx_putn_double_uchar(void **xpp, size_t nelems, const uchar *tp)
#14199  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#14200    ni=Min(nelems-j,LOOPCNT);
#14234 for( ; nelems != 0; nelems--, xp += X_SIZEOF_DOUBLEtp++)
#14247ncx_putn_double_ushort(void **xpp, size_t nelems, const ushort *tp)
#14269  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#14270    ni=Min(nelems-j,LOOPCNT);
#14304 for( ; nelems != 0; nelems--, xp += X_SIZEOF_DOUBLEtp++)
#14317ncx_putn_double_uint(void **xpp, size_t nelems, const uint *tp)
#14339  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#14340    ni=Min(nelems-j,LOOPCNT);
#14374 for( ; nelems != 0; nelems--, xp += X_SIZEOF_DOUBLEtp++)
#14387ncx_putn_double_ulonglong(void **xpp, size_t nelems, const ulonglong *tp)
#14409  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#14410    ni=Min(nelems-j,LOOPCNT);
#14444 for( ; nelems != 0; nelems--, xp += X_SIZEOF_DOUBLEtp++)
#14463ncx_getn_longlong_longlong(const void **xpp, size_t nelems, long long *tp)
#14466 (void) memcpy(tp, *xppnelems * sizeof(long long));
#14468 swapn8b(tp, *xppnelems);
#14470 *xpp = (const void *)((const char *)(*xpp) + nelems * X_SIZEOF_LONGLONG);
#14475ncx_getn_longlong_longlong(const void **xpp, size_t nelemslonglong *tp)
#14497  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#14498    ni=Min(nelems-j,LOOPCNT);
#14527 for( ; nelems != 0; nelems--, xp += X_SIZEOF_LONGLONGtp++)
#14541ncx_getn_longlong_schar(const void **xpp, size_t nelemsschar *tp)
#14563  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#14564    ni=Min(nelems-j,LOOPCNT);
#14593 for( ; nelems != 0; nelems--, xp += X_SIZEOF_LONGLONGtp++)
#14606ncx_getn_longlong_short(const void **xpp, size_t nelems, short *tp)
#14628  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#14629    ni=Min(nelems-j,LOOPCNT);
#14658 for( ; nelems != 0; nelems--, xp += X_SIZEOF_LONGLONGtp++)
#14671ncx_getn_longlong_int(const void **xpp, size_t nelems, int *tp)
#14693  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#14694    ni=Min(nelems-j,LOOPCNT);
#14723 for( ; nelems != 0; nelems--, xp += X_SIZEOF_LONGLONGtp++)
#14736ncx_getn_longlong_float(const void **xpp, size_t nelems, float *tp)
#14758  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#14759    ni=Min(nelems-j,LOOPCNT);
#14788 for( ; nelems != 0; nelems--, xp += X_SIZEOF_LONGLONGtp++)
#14801ncx_getn_longlong_double(const void **xpp, size_t nelems, double *tp)
#14823  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#14824    ni=Min(nelems-j,LOOPCNT);
#14853 for( ; nelems != 0; nelems--, xp += X_SIZEOF_LONGLONGtp++)
#14866ncx_getn_longlong_uchar(const void **xpp, size_t nelemsuchar *tp)
#14888  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#14889    ni=Min(nelems-j,LOOPCNT);
#14918 for( ; nelems != 0; nelems--, xp += X_SIZEOF_LONGLONGtp++)
#14931ncx_getn_longlong_ushort(const void **xpp, size_t nelemsushort *tp)
#14953  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#14954    ni=Min(nelems-j,LOOPCNT);
#14983 for( ; nelems != 0; nelems--, xp += X_SIZEOF_LONGLONGtp++)
#14996ncx_getn_longlong_uint(const void **xpp, size_t nelemsuint *tp)
#15018  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#15019    ni=Min(nelems-j,LOOPCNT);
#15048 for( ; nelems != 0; nelems--, xp += X_SIZEOF_LONGLONGtp++)
#15061ncx_getn_longlong_ulonglong(const void **xpp, size_t nelemsulonglong *tp)
#15083  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#15084    ni=Min(nelems-j,LOOPCNT);
#15113 for( ; nelems != 0; nelems--, xp += X_SIZEOF_LONGLONGtp++)
#15129ncx_putn_longlong_longlong(void **xpp, size_t nelems, const long long *tp)
#15132 (void) memcpy(*xpptpnelems * X_SIZEOF_LONGLONG);
#15134 swapn8b(*xpptpnelems);
#15136 *xpp = (void *)((char *)(*xpp) + nelems * X_SIZEOF_LONGLONG);
#15141ncx_putn_longlong_longlong(void **xpp, size_t nelems, const longlong *tp)
#15163  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#15164    ni=Min(nelems-j,LOOPCNT);
#15198 for( ; nelems != 0; nelems--, xp += X_SIZEOF_LONGLONGtp++)
#15212ncx_putn_longlong_schar(void **xpp, size_t nelems, const schar *tp)
#15234  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#15235    ni=Min(nelems-j,LOOPCNT);
#15269 for( ; nelems != 0; nelems--, xp += X_SIZEOF_LONGLONGtp++)
#15282ncx_putn_longlong_short(void **xpp, size_t nelems, const short *tp)
#15304  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#15305    ni=Min(nelems-j,LOOPCNT);
#15339 for( ; nelems != 0; nelems--, xp += X_SIZEOF_LONGLONGtp++)
#15352ncx_putn_longlong_int(void **xpp, size_t nelems, const int *tp)
#15374  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#15375    ni=Min(nelems-j,LOOPCNT);
#15409 for( ; nelems != 0; nelems--, xp += X_SIZEOF_LONGLONGtp++)
#15422ncx_putn_longlong_float(void **xpp, size_t nelems, const float *tp)
#15444  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#15445    ni=Min(nelems-j,LOOPCNT);
#15479 for( ; nelems != 0; nelems--, xp += X_SIZEOF_LONGLONGtp++)
#15492ncx_putn_longlong_double(void **xpp, size_t nelems, const double *tp)
#15514  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#15515    ni=Min(nelems-j,LOOPCNT);
#15549 for( ; nelems != 0; nelems--, xp += X_SIZEOF_LONGLONGtp++)
#15562ncx_putn_longlong_uchar(void **xpp, size_t nelems, const uchar *tp)
#15584  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#15585    ni=Min(nelems-j,LOOPCNT);
#15619 for( ; nelems != 0; nelems--, xp += X_SIZEOF_LONGLONGtp++)
#15632ncx_putn_longlong_ushort(void **xpp, size_t nelems, const ushort *tp)
#15654  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#15655    ni=Min(nelems-j,LOOPCNT);
#15689 for( ; nelems != 0; nelems--, xp += X_SIZEOF_LONGLONGtp++)
#15702ncx_putn_longlong_uint(void **xpp, size_t nelems, const uint *tp)
#15724  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#15725    ni=Min(nelems-j,LOOPCNT);
#15759 for( ; nelems != 0; nelems--, xp += X_SIZEOF_LONGLONGtp++)
#15772ncx_putn_longlong_ulonglong(void **xpp, size_t nelems, const ulonglong *tp)
#15794  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#15795    ni=Min(nelems-j,LOOPCNT);
#15829 for( ; nelems != 0; nelems--, xp += X_SIZEOF_LONGLONGtp++)
#15847ncx_getn_ulonglong_ulonglong(const void **xpp, size_t nelems, unsigned long long *tp)
#15850 (void) memcpy(tp, *xppnelems * sizeof(unsigned long long));
#15852 swapn8b(tp, *xppnelems);
#15854 *xpp = (const void *)((const char *)(*xpp) + nelems * X_SIZEOF_ULONGLONG);
#15859ncx_getn_ulonglong_ulonglong(const void **xpp, size_t nelemsulonglong *tp)
#15881  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#15882    ni=Min(nelems-j,LOOPCNT);
#15911 for( ; nelems != 0; nelems--, xp += X_SIZEOF_ULONGLONGtp++)
#15925ncx_getn_ulonglong_schar(const void **xpp, size_t nelemsschar *tp)
#15947  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#15948    ni=Min(nelems-j,LOOPCNT);
#15977 for( ; nelems != 0; nelems--, xp += X_SIZEOF_ULONGLONGtp++)
#15990ncx_getn_ulonglong_short(const void **xpp, size_t nelems, short *tp)
#16012  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#16013    ni=Min(nelems-j,LOOPCNT);
#16042 for( ; nelems != 0; nelems--, xp += X_SIZEOF_ULONGLONGtp++)
#16055ncx_getn_ulonglong_int(const void **xpp, size_t nelems, int *tp)
#16077  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#16078    ni=Min(nelems-j,LOOPCNT);
#16107 for( ; nelems != 0; nelems--, xp += X_SIZEOF_ULONGLONGtp++)
#16120ncx_getn_ulonglong_float(const void **xpp, size_t nelems, float *tp)
#16142  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#16143    ni=Min(nelems-j,LOOPCNT);
#16172 for( ; nelems != 0; nelems--, xp += X_SIZEOF_ULONGLONGtp++)
#16185ncx_getn_ulonglong_double(const void **xpp, size_t nelems, double *tp)
#16207  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#16208    ni=Min(nelems-j,LOOPCNT);
#16237 for( ; nelems != 0; nelems--, xp += X_SIZEOF_ULONGLONGtp++)
#16250ncx_getn_ulonglong_longlong(const void **xpp, size_t nelemslonglong *tp)
#16272  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#16273    ni=Min(nelems-j,LOOPCNT);
#16302 for( ; nelems != 0; nelems--, xp += X_SIZEOF_ULONGLONGtp++)
#16315ncx_getn_ulonglong_uchar(const void **xpp, size_t nelemsuchar *tp)
#16337  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#16338    ni=Min(nelems-j,LOOPCNT);
#16367 for( ; nelems != 0; nelems--, xp += X_SIZEOF_ULONGLONGtp++)
#16380ncx_getn_ulonglong_ushort(const void **xpp, size_t nelemsushort *tp)
#16402  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#16403    ni=Min(nelems-j,LOOPCNT);
#16432 for( ; nelems != 0; nelems--, xp += X_SIZEOF_ULONGLONGtp++)
#16445ncx_getn_ulonglong_uint(const void **xpp, size_t nelemsuint *tp)
#16467  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#16468    ni=Min(nelems-j,LOOPCNT);
#16497 for( ; nelems != 0; nelems--, xp += X_SIZEOF_ULONGLONGtp++)
#16513ncx_putn_ulonglong_ulonglong(void **xpp, size_t nelems, const unsigned long long *tp)
#16516 (void) memcpy(*xpptpnelems * X_SIZEOF_ULONGLONG);
#16518 swapn8b(*xpptpnelems);
#16520 *xpp = (void *)((char *)(*xpp) + nelems * X_SIZEOF_ULONGLONG);
#16525ncx_putn_ulonglong_ulonglong(void **xpp, size_t nelems, const ulonglong *tp)
#16547  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#16548    ni=Min(nelems-j,LOOPCNT);
#16582 for( ; nelems != 0; nelems--, xp += X_SIZEOF_ULONGLONGtp++)
#16596ncx_putn_ulonglong_schar(void **xpp, size_t nelems, const schar *tp)
#16618  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#16619    ni=Min(nelems-j,LOOPCNT);
#16653 for( ; nelems != 0; nelems--, xp += X_SIZEOF_ULONGLONGtp++)
#16666ncx_putn_ulonglong_short(void **xpp, size_t nelems, const short *tp)
#16688  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#16689    ni=Min(nelems-j,LOOPCNT);
#16723 for( ; nelems != 0; nelems--, xp += X_SIZEOF_ULONGLONGtp++)
#16736ncx_putn_ulonglong_int(void **xpp, size_t nelems, const int *tp)
#16758  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#16759    ni=Min(nelems-j,LOOPCNT);
#16793 for( ; nelems != 0; nelems--, xp += X_SIZEOF_ULONGLONGtp++)
#16806ncx_putn_ulonglong_float(void **xpp, size_t nelems, const float *tp)
#16828  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#16829    ni=Min(nelems-j,LOOPCNT);
#16863 for( ; nelems != 0; nelems--, xp += X_SIZEOF_ULONGLONGtp++)
#16876ncx_putn_ulonglong_double(void **xpp, size_t nelems, const double *tp)
#16898  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#16899    ni=Min(nelems-j,LOOPCNT);
#16933 for( ; nelems != 0; nelems--, xp += X_SIZEOF_ULONGLONGtp++)
#16946ncx_putn_ulonglong_longlong(void **xpp, size_t nelems, const longlong *tp)
#16968  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#16969    ni=Min(nelems-j,LOOPCNT);
#17003 for( ; nelems != 0; nelems--, xp += X_SIZEOF_ULONGLONGtp++)
#17016ncx_putn_ulonglong_uchar(void **xpp, size_t nelems, const uchar *tp)
#17038  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#17039    ni=Min(nelems-j,LOOPCNT);
#17073 for( ; nelems != 0; nelems--, xp += X_SIZEOF_ULONGLONGtp++)
#17086ncx_putn_ulonglong_ushort(void **xpp, size_t nelems, const ushort *tp)
#17108  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#17109    ni=Min(nelems-j,LOOPCNT);
#17143 for( ; nelems != 0; nelems--, xp += X_SIZEOF_ULONGLONGtp++)
#17156ncx_putn_ulonglong_uint(void **xpp, size_t nelems, const uint *tp)
#17178  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#17179    ni=Min(nelems-j,LOOPCNT);
#17213 for( ; nelems != 0; nelems--, xp += X_SIZEOF_ULONGLONGtp++)
#17234ncx_getn_text(const void **xpp, size_t nelems, signed char *tp)
#17237ncx_getn_text(const void **xpp, size_t nelems, char *tp)
#17240 (void) memcpy(tp, *xppnelems);
#17241 *xpp = (void *)((schar *)(*xpp) + nelems);
#17248ncx_pad_getn_text(const void **xpp, size_t nelems, signed char *tp)
#17251ncx_pad_getn_text(const void **xpp, size_t nelems, char *tp)
#17254 size_t rndup = nelems % X_ALIGN;
#17259 (void) memcpy(tp, *xppnelems);
#17260 *xpp = (void *)((char *)(*xpp) + nelems + rndup);
#17267int ncx_putn_text(void **xpp, size_t nelems, const signed char *tp)
#17270ncx_putn_text(void **xpp, size_t nelems, const char *tp)
#17273 (void) memcpy(*xpptpnelems);
#17274 *xpp = (void *)((char *)(*xpp) + nelems);
#17282ncx_pad_putn_text(void **xpp, size_t nelems, const signed char *tp)
#17285ncx_pad_putn_text(void **xpp, size_t nelems, const char *tp)
#17288 size_t rndup = nelems % X_ALIGN;
#17293 (void) memcpy(*xpptpnelems);
#17294 *xpp = (void *)((char *)(*xpp) + nelems);
#17310ncx_getn_void(const void **xpp, size_t nelems, void *tp)
#17312 (void) memcpy(tp, *xppnelems);
#17313 *xpp = (void *)((schar *)(*xpp) + nelems);
#17319ncx_pad_getn_void(const void **xpp, size_t nelems, void *tp)
#17321 size_t rndup = nelems % X_ALIGN;
#17326 (void) memcpy(tp, *xppnelems);
#17327 *xpp = (void *)((char *)(*xpp) + nelems + rndup);
#17334ncx_putn_void(void **xpp, size_t nelems, const void *tp)
#17336 (void) memcpy(*xpptpnelems);
#17337 *xpp = (void *)((char *)(*xpp) + nelems);
#17344ncx_pad_putn_void(void **xpp, size_t nelems, const void *tp)
#17346 size_t rndup = nelems % X_ALIGN;
#17351 (void) memcpy(*xpptpnelems);
#17352 *xpp = (void *)((char *)(*xpp) + nelems);
ncx.h#118#define ncx_len_char(nelems) \
#119 _RNDUP((nelems), X_ALIGN)
#121#define ncx_len_short(nelems) \
#122 (((nelems) + (nelems)%2)  * X_SIZEOF_SHORT)
#124#define ncx_len_int(nelems) \
#125 ((nelems) * X_SIZEOF_INT)
#127#define ncx_len_long(nelems) \
#128 ((nelems) * X_SIZEOF_LONG)
#130#define ncx_len_float(nelems) \
#131 ((nelems) * X_SIZEOF_FLOAT)
#133#define ncx_len_double(nelems) \
#134 ((nelems) * X_SIZEOF_DOUBLE)
#136#define ncx_len_ubyte(nelems) \
#137 _RNDUP((nelems), X_ALIGN)
#139#define ncx_len_ushort(nelems) \
#140 (((nelems) + (nelems)%2)  * X_SIZEOF_USHORT)
#142#define ncx_len_uint(nelems) \
#143 ((nelems) * X_SIZEOF_UINT)
#145#define ncx_len_int64(nelems) \
#146 ((nelems) * X_SIZEOF_INT64)
#148#define ncx_len_uint64(nelems) \
#149 ((nelems) * X_SIZEOF_UINT64)
#317ncx_getn_schar_schar (const void **xpp, size_t nelemsschar  *ip);
#319ncx_getn_schar_uchar (const void **xpp, size_t nelemsuchar  *ip);
#321ncx_getn_schar_short (const void **xpp, size_t nelems, short  *ip);
#323ncx_getn_schar_ushort(const void **xpp, size_t nelemsushort *ip);
#325ncx_getn_schar_int   (const void **xpp, size_t nelems, int    *ip);
#327ncx_getn_schar_uint  (const void **xpp, size_t nelemsuint   *ip);
#329ncx_getn_schar_long  (const void **xpp, size_t nelems, long   *ip);
#331ncx_getn_schar_float (const void **xpp, size_t nelems, float  *ip);
#333ncx_getn_schar_double(const void **xpp, size_t nelems, double *ip);
#335ncx_getn_schar_longlong (const void **xpp, size_t nelemslonglong  *ip);
#337ncx_getn_schar_ulonglong(const void **xpp, size_t nelemsulonglong *ip);
#340ncx_pad_getn_schar_schar (const void **xpp, size_t nelemsschar  *ip);
#342ncx_pad_getn_schar_uchar (const void **xpp, size_t nelemsuchar  *ip);
#344ncx_pad_getn_schar_short (const void **xpp, size_t nelems, short  *ip);
#346ncx_pad_getn_schar_ushort(const void **xpp, size_t nelemsushort *ip);
#348ncx_pad_getn_schar_int   (const void **xpp, size_t nelems, int    *ip);
#350ncx_pad_getn_schar_uint  (const void **xpp, size_t nelemsuint   *ip);
#352ncx_pad_getn_schar_long  (const void **xpp, size_t nelems, long   *ip);
#354ncx_pad_getn_schar_float (const void **xpp, size_t nelems, float  *ip);
#356ncx_pad_getn_schar_double(const void **xpp, size_t nelems, double *ip);
#358ncx_pad_getn_schar_longlong (const void **xpp, size_t nelemslonglong  *ip);
#360ncx_pad_getn_schar_ulonglong(const void **xpp, size_t nelemsulonglong *ip);
#363ncx_putn_schar_schar (void **xpp, size_t nelems, const schar   *ip);
#365ncx_putn_schar_uchar (void **xpp, size_t nelems, const uchar  *ip);
#367ncx_putn_schar_short (void **xpp, size_t nelems, const short  *ip);
#369ncx_putn_schar_ushort(void **xpp, size_t nelems, const ushort *ip);
#371ncx_putn_schar_int   (void **xpp, size_t nelems, const int    *ip);
#373ncx_putn_schar_uint  (void **xpp, size_t nelems, const uint   *ip);
#375ncx_putn_schar_long  (void **xpp, size_t nelems, const long   *ip);
#377ncx_putn_schar_float (void **xpp, size_t nelems, const float  *ip);
#379ncx_putn_schar_double(void **xpp, size_t nelems, const double  *ip);
#381ncx_putn_schar_longlong (void **xpp, size_t nelems, const longlong  *ip);
#383ncx_putn_schar_ulonglong(void **xpp, size_t nelems, const ulonglong *ip);
#386ncx_pad_putn_schar_schar (void **xpp, size_t nelems, const schar  *ip);
#388ncx_pad_putn_schar_uchar (void **xpp, size_t nelems, const uchar  *ip);
#390ncx_pad_putn_schar_short (void **xpp, size_t nelems, const short  *ip);
#392ncx_pad_putn_schar_ushort(void **xpp, size_t nelems, const ushort *ip);
#394ncx_pad_putn_schar_int   (void **xpp, size_t nelems, const int    *ip);
#396ncx_pad_putn_schar_uint  (void **xpp, size_t nelems, const uint   *ip);
#398ncx_pad_putn_schar_long  (void **xpp, size_t nelems, const long   *ip);
#400ncx_pad_putn_schar_float (void **xpp, size_t nelems, const float  *ip);
#402ncx_pad_putn_schar_double(void **xpp, size_t nelems, const double *ip);
#404ncx_pad_putn_schar_longlong (void **xpp, size_t nelems, const longlong  *ip);
#406ncx_pad_putn_schar_ulonglong(void **xpp, size_t nelems, const ulonglong *ip);
#410ncx_getn_uchar_schar (const void **xpp, size_t nelemsschar  *ip);
#412ncx_getn_uchar_uchar (const void **xpp, size_t nelemsuchar  *ip);
#414ncx_getn_uchar_short (const void **xpp, size_t nelems, short  *ip);
#416ncx_getn_uchar_ushort(const void **xpp, size_t nelemsushort *ip);
#418ncx_getn_uchar_int   (const void **xpp, size_t nelems, int    *ip);
#420ncx_getn_uchar_uint  (const void **xpp, size_t nelemsuint   *ip);
#422ncx_getn_uchar_long  (const void **xpp, size_t nelems, long   *ip);
#424ncx_getn_uchar_float (const void **xpp, size_t nelems, float  *ip);
#426ncx_getn_uchar_double(const void **xpp, size_t nelems, double *ip);
#428ncx_getn_uchar_longlong (const void **xpp, size_t nelemslonglong  *ip);
#430ncx_getn_uchar_ulonglong(const void **xpp, size_t nelemsulonglong *ip);
#433ncx_pad_getn_uchar_schar (const void **xpp, size_t nelemsschar  *ip);
#435ncx_pad_getn_uchar_uchar (const void **xpp, size_t nelemsuchar  *ip);
#437ncx_pad_getn_uchar_short (const void **xpp, size_t nelems, short  *ip);
#439ncx_pad_getn_uchar_ushort(const void **xpp, size_t nelemsushort *ip);
#441ncx_pad_getn_uchar_int   (const void **xpp, size_t nelems, int    *ip);
#443ncx_pad_getn_uchar_uint  (const void **xpp, size_t nelemsuint   *ip);
#445ncx_pad_getn_uchar_long  (const void **xpp, size_t nelems, long   *ip);
#447ncx_pad_getn_uchar_float (const void **xpp, size_t nelems, float  *ip);
#449ncx_pad_getn_uchar_double(const void **xpp, size_t nelems, double *ip);
#451ncx_pad_getn_uchar_longlong (const void **xpp, size_t nelemslonglong  *ip);
#453ncx_pad_getn_uchar_ulonglong(const void **xpp, size_t nelemsulonglong *ip);
#456ncx_putn_uchar_schar (void **xpp, size_t nelems, const schar   *ip);
#458ncx_putn_uchar_uchar (void **xpp, size_t nelems, const uchar  *ip);
#460ncx_putn_uchar_short (void **xpp, size_t nelems, const short  *ip);
#462ncx_putn_uchar_ushort(void **xpp, size_t nelems, const ushort *ip);
#464ncx_putn_uchar_int   (void **xpp, size_t nelems, const int    *ip);
#466ncx_putn_uchar_uint  (void **xpp, size_t nelems, const uint   *ip);
#468ncx_putn_uchar_long  (void **xpp, size_t nelems, const long   *ip);
#470ncx_putn_uchar_float (void **xpp, size_t nelems, const float  *ip);
#472ncx_putn_uchar_double(void **xpp, size_t nelems, const double  *ip);
#474ncx_putn_uchar_longlong (void **xpp, size_t nelems, const longlong  *ip);
#476ncx_putn_uchar_ulonglong(void **xpp, size_t nelems, const ulonglong *ip);
#479ncx_pad_putn_uchar_schar (void **xpp, size_t nelems, const schar  *ip);
#481ncx_pad_putn_uchar_uchar (void **xpp, size_t nelems, const uchar  *ip);
#483ncx_pad_putn_uchar_short (void **xpp, size_t nelems, const short  *ip);
#485ncx_pad_putn_uchar_ushort(void **xpp, size_t nelems, const ushort *ip);
#487ncx_pad_putn_uchar_int   (void **xpp, size_t nelems, const int    *ip);
#489ncx_pad_putn_uchar_uint  (void **xpp, size_t nelems, const uint   *ip);
#491ncx_pad_putn_uchar_long  (void **xpp, size_t nelems, const long   *ip);
#493ncx_pad_putn_uchar_float (void **xpp, size_t nelems, const float  *ip);
#495ncx_pad_putn_uchar_double(void **xpp, size_t nelems, const double *ip);
#497ncx_pad_putn_uchar_longlong (void **xpp, size_t nelems, const longlong  *ip);
#499ncx_pad_putn_uchar_ulonglong(void **xpp, size_t nelems, const ulonglong *ip);
#503ncx_getn_short_schar (const void **xpp, size_t nelemsschar  *ip);
#505ncx_getn_short_uchar (const void **xpp, size_t nelemsuchar  *ip);
#507ncx_getn_short_short (const void **xpp, size_t nelems, short  *ip);
#509ncx_getn_short_ushort(const void **xpp, size_t nelemsushort *ip);
#511ncx_getn_short_int   (const void **xpp, size_t nelems, int    *ip);
#513ncx_getn_short_uint  (const void **xpp, size_t nelemsuint   *ip);
#515ncx_getn_short_long  (const void **xpp, size_t nelems, long   *ip);
#517ncx_getn_short_float (const void **xpp, size_t nelems, float  *ip);
#519ncx_getn_short_double(const void **xpp, size_t nelems, double *ip);
#521ncx_getn_short_longlong (const void **xpp, size_t nelemslonglong  *ip);
#523ncx_getn_short_ulonglong(const void **xpp, size_t nelemsulonglong *ip);
#526ncx_pad_getn_short_schar (const void **xpp, size_t nelemsschar  *ip);
#528ncx_pad_getn_short_uchar (const void **xpp, size_t nelemsuchar  *ip);
#530ncx_pad_getn_short_short (const void **xpp, size_t nelems, short  *ip);
#532ncx_pad_getn_short_ushort(const void **xpp, size_t nelemsushort *ip);
#534ncx_pad_getn_short_int   (const void **xpp, size_t nelems, int    *ip);
#536ncx_pad_getn_short_uint  (const void **xpp, size_t nelemsuint   *ip);
#538ncx_pad_getn_short_long  (const void **xpp, size_t nelems, long   *ip);
#540ncx_pad_getn_short_float (const void **xpp, size_t nelems, float  *ip);
#542ncx_pad_getn_short_double(const void **xpp, size_t nelems, double *ip);
#544ncx_pad_getn_short_longlong (const void **xpp, size_t nelemslonglong  *ip);
#546ncx_pad_getn_short_ulonglong(const void **xpp, size_t nelemsulonglong *ip);
#549ncx_putn_short_schar (void **xpp, size_t nelems, const schar  *ip);
#551ncx_putn_short_uchar (void **xpp, size_t nelems, const uchar  *ip);
#553ncx_putn_short_short (void **xpp, size_t nelems, const short  *ip);
#555ncx_putn_short_ushort(void **xpp, size_t nelems, const ushort *ip);
#557ncx_putn_short_int   (void **xpp, size_t nelems, const int    *ip);
#559ncx_putn_short_uint  (void **xpp, size_t nelems, const uint   *ip);
#561ncx_putn_short_long  (void **xpp, size_t nelems, const long   *ip);
#563ncx_putn_short_float (void **xpp, size_t nelems, const float  *ip);
#565ncx_putn_short_double(void **xpp, size_t nelems, const double *ip);
#567ncx_putn_short_longlong (void **xpp, size_t nelems, const longlong  *ip);
#569ncx_putn_short_ulonglong(void **xpp, size_t nelems, const ulonglong *ip);
#572ncx_pad_putn_short_schar (void **xpp, size_t nelems, const schar  *ip);
#574ncx_pad_putn_short_uchar (void **xpp, size_t nelems, const uchar  *ip);
#576ncx_pad_putn_short_short (void **xpp, size_t nelems, const short  *ip);
#578ncx_pad_putn_short_ushort(void **xpp, size_t nelems, const ushort *ip);
#580ncx_pad_putn_short_int   (void **xpp, size_t nelems, const int    *ip);
#582ncx_pad_putn_short_uint  (void **xpp, size_t nelems, const uint   *ip);
#584ncx_pad_putn_short_long  (void **xpp, size_t nelems, const long   *ip);
#586ncx_pad_putn_short_float (void **xpp, size_t nelems, const float  *ip);
#588ncx_pad_putn_short_double(void **xpp, size_t nelems, const double *ip);
#590ncx_pad_putn_short_longlong (void **xpp, size_t nelems, const longlong  *ip);
#592ncx_pad_putn_short_ulonglong(void **xpp, size_t nelems, const ulonglong *ip);
#596ncx_getn_ushort_schar (const void **xpp, size_t nelemsschar  *ip);
#598ncx_getn_ushort_uchar (const void **xpp, size_t nelemsuchar  *ip);
#600ncx_getn_ushort_short (const void **xpp, size_t nelems, short  *ip);
#602ncx_getn_ushort_ushort(const void **xpp, size_t nelemsushort *ip);
#604ncx_getn_ushort_int   (const void **xpp, size_t nelems, int    *ip);
#606ncx_getn_ushort_uint  (const void **xpp, size_t nelemsuint   *ip);
#608ncx_getn_ushort_long  (const void **xpp, size_t nelems, long   *ip);
#610ncx_getn_ushort_float (const void **xpp, size_t nelems, float  *ip);
#612ncx_getn_ushort_double(const void **xpp, size_t nelems, double *ip);
#614ncx_getn_ushort_longlong (const void **xpp, size_t nelemslonglong  *ip);
#616ncx_getn_ushort_ulonglong(const void **xpp, size_t nelemsulonglong *ip);
#619ncx_pad_getn_ushort_schar (const void **xpp, size_t nelemsschar  *ip);
#621ncx_pad_getn_ushort_uchar (const void **xpp, size_t nelemsuchar  *ip);
#623ncx_pad_getn_ushort_short (const void **xpp, size_t nelems, short  *ip);
#625ncx_pad_getn_ushort_ushort(const void **xpp, size_t nelemsushort *ip);
#627ncx_pad_getn_ushort_int   (const void **xpp, size_t nelems, int    *ip);
#629ncx_pad_getn_ushort_uint  (const void **xpp, size_t nelemsuint   *ip);
#631ncx_pad_getn_ushort_long  (const void **xpp, size_t nelems, long   *ip);
#633ncx_pad_getn_ushort_float (const void **xpp, size_t nelems, float  *ip);
#635ncx_pad_getn_ushort_double(const void **xpp, size_t nelems, double *ip);
#637ncx_pad_getn_ushort_longlong (const void **xpp, size_t nelemslonglong  *ip);
#639ncx_pad_getn_ushort_ulonglong(const void **xpp, size_t nelemsulonglong *ip);
#642ncx_putn_ushort_schar (void **xpp, size_t nelems, const schar  *ip);
#644ncx_putn_ushort_uchar (void **xpp, size_t nelems, const uchar  *ip);
#646ncx_putn_ushort_short (void **xpp, size_t nelems, const short  *ip);
#648ncx_putn_ushort_ushort(void **xpp, size_t nelems, const ushort *ip);
#650ncx_putn_ushort_int   (void **xpp, size_t nelems, const int    *ip);
#652ncx_putn_ushort_uint  (void **xpp, size_t nelems, const uint   *ip);
#654ncx_putn_ushort_long  (void **xpp, size_t nelems, const long   *ip);
#656ncx_putn_ushort_float (void **xpp, size_t nelems, const float  *ip);
#658ncx_putn_ushort_double(void **xpp, size_t nelems, const double *ip);
#660ncx_putn_ushort_longlong (void **xpp, size_t nelems, const longlong  *ip);
#662ncx_putn_ushort_ulonglong(void **xpp, size_t nelems, const ulonglong *ip);
#665ncx_pad_putn_ushort_schar (void **xpp, size_t nelems, const schar  *ip);
#667ncx_pad_putn_ushort_uchar (void **xpp, size_t nelems, const uchar  *ip);
#669ncx_pad_putn_ushort_short (void **xpp, size_t nelems, const short  *ip);
#671ncx_pad_putn_ushort_ushort(void **xpp, size_t nelems, const ushort *ip);
#673ncx_pad_putn_ushort_int   (void **xpp, size_t nelems, const int    *ip);
#675ncx_pad_putn_ushort_uint  (void **xpp, size_t nelems, const uint   *ip);
#677ncx_pad_putn_ushort_long  (void **xpp, size_t nelems, const long   *ip);
#679ncx_pad_putn_ushort_float (void **xpp, size_t nelems, const float  *ip);
#681ncx_pad_putn_ushort_double(void **xpp, size_t nelems, const double *ip);
#683ncx_pad_putn_ushort_longlong (void **xpp, size_t nelems, const longlong  *ip);
#685ncx_pad_putn_ushort_ulonglong(void **xpp, size_t nelems, const ulonglong *ip);
#689ncx_getn_int_schar (const void **xpp, size_t nelemsschar  *ip);
#691ncx_getn_int_uchar (const void **xpp, size_t nelemsuchar  *ip);
#693ncx_getn_int_short (const void **xpp, size_t nelems, short  *ip);
#695ncx_getn_int_ushort(const void **xpp, size_t nelemsushort *ip);
#697ncx_getn_int_int   (const void **xpp, size_t nelems, int    *ip);
#699ncx_getn_int_uint  (const void **xpp, size_t nelemsuint   *ip);
#701ncx_getn_int_long  (const void **xpp, size_t nelems, long   *ip);
#703ncx_getn_long_long (const void **xpp, size_t nelems, long   *ip);
#705ncx_getn_int_float (const void **xpp, size_t nelems, float  *ip);
#707ncx_getn_int_double(const void **xpp, size_t nelems, double *ip);
#709ncx_getn_int_longlong (const void **xpp, size_t nelemslonglong  *ip);
#711ncx_getn_int_ulonglong(const void **xpp, size_t nelemsulonglong *ip);
#714ncx_putn_int_schar (void **xpp, size_t nelems, const schar  *ip);
#716ncx_putn_int_uchar (void **xpp, size_t nelems, const uchar  *ip);
#718ncx_putn_int_short (void **xpp, size_t nelems, const short  *ip);
#720ncx_putn_int_ushort(void **xpp, size_t nelems, const ushort *ip);
#722ncx_putn_int_int   (void **xpp, size_t nelems, const int    *ip);
#724ncx_putn_int_uint  (void **xpp, size_t nelems, const uint   *ip);
#726ncx_putn_int_long  (void **xpp, size_t nelems, const long   *ip);
#728ncx_putn_long_long (void **xpp, size_t nelems, const long   *ip);
#730ncx_putn_int_float (void **xpp, size_t nelems, const float  *ip);
#732ncx_putn_int_double(void **xpp, size_t nelems, const double *ip);
#734ncx_putn_int_longlong (void **xpp, size_t nelems, const longlong  *ip);
#736ncx_putn_int_ulonglong(void **xpp, size_t nelems, const ulonglong *ip);
#740ncx_getn_uint_schar (const void **xpp, size_t nelemsschar  *ip);
#742ncx_getn_uint_uchar (const void **xpp, size_t nelemsuchar  *ip);
#744ncx_getn_uint_short (const void **xpp, size_t nelems, short  *ip);
#746ncx_getn_uint_ushort(const void **xpp, size_t nelemsushort *ip);
#748ncx_getn_uint_int   (const void **xpp, size_t nelems, int    *ip);
#750ncx_getn_uint_uint  (const void **xpp, size_t nelemsuint   *ip);
#752ncx_getn_uint_long  (const void **xpp, size_t nelems, long   *ip);
#754ncx_getn_long_long (const void **xpp, size_t nelems, long   *ip);
#756ncx_getn_uint_float (const void **xpp, size_t nelems, float  *ip);
#758ncx_getn_uint_double(const void **xpp, size_t nelems, double *ip);
#760ncx_getn_uint_longlong (const void **xpp, size_t nelemslonglong  *ip);
#762ncx_getn_uint_ulonglong(const void **xpp, size_t nelemsulonglong *ip);
#765ncx_putn_uint_schar (void **xpp, size_t nelems, const schar  *ip);
#767ncx_putn_uint_uchar (void **xpp, size_t nelems, const uchar  *ip);
#769ncx_putn_uint_short (void **xpp, size_t nelems, const short  *ip);
#771ncx_putn_uint_ushort(void **xpp, size_t nelems, const ushort *ip);
#773ncx_putn_uint_int   (void **xpp, size_t nelems, const int    *ip);
#775ncx_putn_uint_uint  (void **xpp, size_t nelems, const uint   *ip);
#777ncx_putn_uint_long  (void **xpp, size_t nelems, const long   *ip);
#779ncx_putn_long_long (void **xpp, size_t nelems, const long   *ip);
#781ncx_putn_uint_float (void **xpp, size_t nelems, const float  *ip);
#783ncx_putn_uint_double(void **xpp, size_t nelems, const double *ip);
#785ncx_putn_uint_longlong (void **xpp, size_t nelems, const longlong  *ip);
#787ncx_putn_uint_ulonglong(void **xpp, size_t nelems, const ulonglong *ip);
#791ncx_getn_float_schar (const void **xpp, size_t nelemsschar  *ip);
#793ncx_getn_float_uchar (const void **xpp, size_t nelemsuchar  *ip);
#795ncx_getn_float_short (const void **xpp, size_t nelems, short  *ip);
#797ncx_getn_float_ushort(const void **xpp, size_t nelemsushort *ip);
#799ncx_getn_float_int   (const void **xpp, size_t nelems, int    *ip);
#801ncx_getn_float_uint  (const void **xpp, size_t nelemsuint   *ip);
#803ncx_getn_float_long  (const void **xpp, size_t nelems, long   *ip);
#805ncx_getn_float_float (const void **xpp, size_t nelems, float  *ip);
#807ncx_getn_float_double(const void **xpp, size_t nelems, double *ip);
#809ncx_getn_float_longlong (const void **xpp, size_t nelemslonglong  *ip);
#811ncx_getn_float_ulonglong(const void **xpp, size_t nelemsulonglong *ip);
#814ncx_putn_float_schar (void **xpp, size_t nelems, const schar  *ip);
#816ncx_putn_float_uchar (void **xpp, size_t nelems, const uchar  *ip);
#818ncx_putn_float_short (void **xpp, size_t nelems, const short  *ip);
#820ncx_putn_float_ushort(void **xpp, size_t nelems, const ushort *ip);
#822ncx_putn_float_int   (void **xpp, size_t nelems, const int    *ip);
#824ncx_putn_float_uint  (void **xpp, size_t nelems, const uint   *ip);
#826ncx_putn_float_long  (void **xpp, size_t nelems, const long   *ip);
#828ncx_putn_float_float (void **xpp, size_t nelems, const float  *ip);
#830ncx_putn_float_double(void **xpp, size_t nelems, const double *ip);
#832ncx_putn_float_longlong (void **xpp, size_t nelems, const longlong  *ip);
#834ncx_putn_float_ulonglong(void **xpp, size_t nelems, const ulonglong *ip);
#838ncx_getn_double_schar (const void **xpp, size_t nelemsschar  *ip);
#840ncx_getn_double_uchar (const void **xpp, size_t nelemsuchar  *ip);
#842ncx_getn_double_short (const void **xpp, size_t nelems, short  *ip);
#844ncx_getn_double_ushort(const void **xpp, size_t nelemsushort  *ip);
#846ncx_getn_double_int   (const void **xpp, size_t nelems, int    *ip);
#848ncx_getn_double_uint  (const void **xpp, size_t nelemsuint   *ip);
#850ncx_getn_double_long  (const void **xpp, size_t nelems, long   *ip);
#852ncx_getn_double_float (const void **xpp, size_t nelems, float  *ip);
#854ncx_getn_double_double(const void **xpp, size_t nelems, double *ip);
#856ncx_getn_double_longlong (const void **xpp, size_t nelemslonglong  *ip);
#858ncx_getn_double_ulonglong(const void **xpp, size_t nelemsulonglong *ip);
#861ncx_putn_double_schar (void **xpp, size_t nelems, const schar  *ip);
#863ncx_putn_double_uchar (void **xpp, size_t nelems, const uchar  *ip);
#865ncx_putn_double_short (void **xpp, size_t nelems, const short  *ip);
#867ncx_putn_double_ushort(void **xpp, size_t nelems, const ushort *ip);
#869ncx_putn_double_int   (void **xpp, size_t nelems, const int    *ip);
#871ncx_putn_double_uint  (void **xpp, size_t nelems, const uint   *ip);
#873ncx_putn_double_long  (void **xpp, size_t nelems, const long   *ip);
#875ncx_putn_double_float (void **xpp, size_t nelems, const float  *ip);
#877ncx_putn_double_double(void **xpp, size_t nelems, const double *ip);
#879ncx_putn_double_longlong (void **xpp, size_t nelems, const longlong  *ip);
#881ncx_putn_double_ulonglong(void **xpp, size_t nelems, const ulonglong *ip);
#885ncx_getn_longlong_schar (const void **xpp, size_t nelemsschar  *ip);
#887ncx_getn_longlong_uchar (const void **xpp, size_t nelemsuchar  *ip);
#889ncx_getn_longlong_short (const void **xpp, size_t nelems, short  *ip);
#891ncx_getn_longlong_ushort(const void **xpp, size_t nelemsushort  *ip);
#893ncx_getn_longlong_int   (const void **xpp, size_t nelems, int    *ip);
#895ncx_getn_longlong_uint  (const void **xpp, size_t nelemsuint   *ip);
#897ncx_getn_longlong_long  (const void **xpp, size_t nelems, long   *ip);
#899ncx_getn_longlong_float (const void **xpp, size_t nelems, float  *ip);
#901ncx_getn_longlong_double(const void **xpp, size_t nelems, double *ip);
#903ncx_getn_longlong_longlong (const void **xpp, size_t nelemslonglong  *ip);
#905ncx_getn_longlong_ulonglong(const void **xpp, size_t nelemsulonglong *ip);
#908ncx_putn_longlong_schar (void **xpp, size_t nelems, const schar  *ip);
#910ncx_putn_longlong_uchar (void **xpp, size_t nelems, const uchar  *ip);
#912ncx_putn_longlong_short (void **xpp, size_t nelems, const short  *ip);
#914ncx_putn_longlong_ushort(void **xpp, size_t nelems, const ushort *ip);
#916ncx_putn_longlong_int   (void **xpp, size_t nelems, const int    *ip);
#918ncx_putn_longlong_uint  (void **xpp, size_t nelems, const uint   *ip);
#920ncx_putn_longlong_long  (void **xpp, size_t nelems, const long   *ip);
#922ncx_putn_longlong_float (void **xpp, size_t nelems, const float  *ip);
#924ncx_putn_longlong_double(void **xpp, size_t nelems, const double *ip);
#926ncx_putn_longlong_longlong (void **xpp, size_t nelems, const longlong  *ip);
#928ncx_putn_longlong_ulonglong(void **xpp, size_t nelems, const ulonglong *ip);
#932ncx_getn_ulonglong_schar (const void **xpp, size_t nelemsschar  *ip);
#934ncx_getn_ulonglong_uchar (const void **xpp, size_t nelemsuchar  *ip);
#936ncx_getn_ulonglong_short (const void **xpp, size_t nelems, short  *ip);
#938ncx_getn_ulonglong_ushort(const void **xpp, size_t nelemsushort  *ip);
#940ncx_getn_ulonglong_int   (const void **xpp, size_t nelems, int    *ip);
#942ncx_getn_ulonglong_uint  (const void **xpp, size_t nelemsuint   *ip);
#944ncx_getn_ulonglong_long  (const void **xpp, size_t nelems, long   *ip);
#946ncx_getn_ulonglong_float (const void **xpp, size_t nelems, float  *ip);
#948ncx_getn_ulonglong_double(const void **xpp, size_t nelems, double *ip);
#950ncx_getn_ulonglong_longlong (const void **xpp, size_t nelemslonglong  *ip);
#952ncx_getn_ulonglong_ulonglong(const void **xpp, size_t nelemsulonglong *ip);
#955ncx_putn_ulonglong_schar (void **xpp, size_t nelems, const schar  *ip);
#957ncx_putn_ulonglong_uchar (void **xpp, size_t nelems, const uchar  *ip);
#959ncx_putn_ulonglong_short (void **xpp, size_t nelems, const short  *ip);
#961ncx_putn_ulonglong_ushort(void **xpp, size_t nelems, const ushort *ip);
#963ncx_putn_ulonglong_int   (void **xpp, size_t nelems, const int    *ip);
#965ncx_putn_ulonglong_uint  (void **xpp, size_t nelems, const uint   *ip);
#967ncx_putn_ulonglong_long  (void **xpp, size_t nelems, const long   *ip);
#969ncx_putn_ulonglong_float (void **xpp, size_t nelems, const float  *ip);
#971ncx_putn_ulonglong_double(void **xpp, size_t nelems, const double *ip);
#973ncx_putn_ulonglong_longlong (void **xpp, size_t nelems, const longlong  *ip);
#975ncx_putn_ulonglong_ulonglong(void **xpp, size_t nelems, const ulonglong *ip);
#1012#define ncx_getn_char_char(xppnelemsfillpncx_getn_text(xppnelemsfillp)
#1013#define ncx_putn_char_char(xppnelemsfillpncx_putn_text(xppnelemsfillp)
netcdf.h#881nc_set_chunk_cache(size_t size, size_t nelems, float preemption);
#889nc_set_var_chunk_cache(int ncid, int varid, size_t size, size_t nelems,
netcdf_f.h#30nc_set_chunk_cache_ints(int size, int nelems, int preemption);
#36nc_set_var_chunk_cache_ints(int ncid, int varid, int size, int nelems,
ocdebug.c#35occalloc(size_t size, size_t nelems)
#37    return ocmalloc(size*nelems);
ocdebug.h#77extern void* occalloc(size_t size, size_t nelems);
onstack.h#51# define ALLOC_ONSTACK(nametypenelems) \
#52 type *const name = (type *) alloca((ALLOCA_ARG_T)((nelems) * sizeof(type)))
#61# define ALLOC_ONSTACK(nametypenelems) \
#62 type name[nelems]
#76# define ALLOC_ONSTACK(nametypenelems) \
#77 type *const name = (type *) malloc((nelems) * sizeof(type))
putget.c#32        const size_t nelems, void* value, const nc_type memtype);
#35         const size_t nelems, const void* value, const nc_type memtype);
#83 size_t nelems) /* how many */
#87 assert(nelems <= sizeof(fillp)/sizeof(fillp[0]));
#91 const schar *const end = vp + nelems;
#97 return ncx_putn_schar_schar(xppnelemsfillp);
#103 size_t nelems) /* how many */
#107 assert(nelems <= sizeof(fillp)/sizeof(fillp[0]));
#111 const char *const end = vp + nelems;
#117 return ncx_putn_char_char(xppnelemsfillp);
#123 size_t nelems) /* how many */
#127 assert(nelems <= sizeof(fillp)/sizeof(fillp[0]));
#131 const short *const end = vp + nelems;
#137 return ncx_putn_short_short(xppnelemsfillp);
#145 size_t nelems) /* how many */
#149 assert(nelems <= sizeof(fillp)/sizeof(fillp[0]));
#153 const int *const end = vp + nelems;
#159 return ncx_putn_int_int(xppnelemsfillp);
#166 size_t nelems) /* how many */
#170 assert(nelems <= sizeof(fillp)/sizeof(fillp[0]));
#174 const long *const end = vp + nelems;
#180 return ncx_putn_int_long(xppnelemsfillp);
#190 size_t nelems) /* how many */
#194 assert(nelems <= sizeof(fillp)/sizeof(fillp[0]));
#198 const float *const end = vp + nelems;
#204 return ncx_putn_float_float(xppnelemsfillp);
#210 size_t nelems) /* how many */
#214 assert(nelems <= sizeof(fillp)/sizeof(fillp[0]));
#218 const double *const end = vp + nelems;
#224 return ncx_putn_double_double(xppnelemsfillp);
#231 size_t nelems) /* how many */
#235 assert(nelems <= sizeof(fillp)/sizeof(fillp[0]));
#239 const uchar *const end = vp + nelems;
#245 return ncx_putn_uchar_uchar(xppnelemsfillp);
#251 size_t nelems) /* how many */
#255 assert(nelems <= sizeof(fillp)/sizeof(fillp[0]));
#259 const ushort *const end = vp + nelems;
#265 return ncx_putn_ushort_ushort(xppnelemsfillp);
#271 size_t nelems) /* how many */
#275 assert(nelems <= sizeof(fillp)/sizeof(fillp[0]));
#279 const uint *const end = vp + nelems;
#285 return ncx_putn_uint_uint(xppnelemsfillp);
#291 size_t nelems) /* how many */
#295 assert(nelems <= sizeof(fillp)/sizeof(fillp[0]));
#299 const longlong *const end = vp + nelems;
#305 return ncx_putn_longlong_longlong(xppnelemsfillp);
#311 size_t nelems) /* how many */
#315 assert(nelems <= sizeof(fillp)/sizeof(fillp[0]));
#319 const ulonglong *const end = vp + nelems;
#325 return ncx_putn_ulonglong_ulonglong(xppnelemsfillp);
#345 const size_t nelems = sizeof(xfillp)/step;
#346 const size_t xsz = varp->xsz * nelems;
#361 if( (*attrpp)->type != varp->type || (*attrpp)->nelems != 1 )
#390 status = NC_fill_schar(&xpnelems);
#393 status = NC_fill_char(&xpnelems);
#396 status = NC_fill_short(&xpnelems);
#399 status = NC_fill_int(&xpnelems);
#402 status = NC_fill_float(&xpnelems);
#405 status = NC_fill_double(&xpnelems);
#408                        status = NC_fill_uchar(&xpnelems);
#411                        status = NC_fill_ushort(&xpnelems);
#414                        status = NC_fill_uint(&xpnelems);
#417                        status = NC_fill_longlong(&xpnelems);
#420                        status = NC_fill_ulonglong(&xpnelems);
#509 for(; ii < ncp->vars.nelemsii++, varpp++)
#559 for(; ii < ncp->vars.nelemsii++, varpp++)
#659     NC_var *const *const end = &vpp[ncp->vars.nelems];
#862  const size_t *start, size_t nelems, const char *value)
#865 size_t remaining = varp->xsz * nelems;
#869 if(nelems == 0)
#908  const size_t *start, size_t nelems, const schar *value)
#911 size_t remaining = varp->xsz * nelems;
#915 if(nelems == 0)
#953  const size_t *start, size_t nelems, const uchar *value)
#956 size_t remaining = varp->xsz * nelems;
#960 if(nelems == 0)
#998  const size_t *start, size_t nelems, const short *value)
#1001 size_t remaining = varp->xsz * nelems;
#1005 if(nelems == 0)
#1043  const size_t *start, size_t nelems, const int *value)
#1046 size_t remaining = varp->xsz * nelems;
#1050 if(nelems == 0)
#1088  const size_t *start, size_t nelems, const float *value)
#1091 size_t remaining = varp->xsz * nelems;
#1095 if(nelems == 0)
#1133  const size_t *start, size_t nelems, const double *value)
#1136 size_t remaining = varp->xsz * nelems;
#1140 if(nelems == 0)
#1178  const size_t *start, size_t nelems, const longlong *value)
#1181 size_t remaining = varp->xsz * nelems;
#1185 if(nelems == 0)
#1223  const size_t *start, size_t nelems, const ushort *value)
#1226 size_t remaining = varp->xsz * nelems;
#1230 if(nelems == 0)
#1268  const size_t *start, size_t nelems, const uint *value)
#1271 size_t remaining = varp->xsz * nelems;
#1275 if(nelems == 0)
#1313  const size_t *start, size_t nelems, const ulonglong *value)
#1316 size_t remaining = varp->xsz * nelems;
#1320 if(nelems == 0)
#1359  const size_t *start, size_t nelems, const schar *value)
#1362 size_t remaining = varp->xsz * nelems;
#1366 if(nelems == 0)
#1404  const size_t *start, size_t nelems, const uchar *value)
#1407 size_t remaining = varp->xsz * nelems;
#1411 if(nelems == 0)
#1449  const size_t *start, size_t nelems, const short *value)
#1452 size_t remaining = varp->xsz * nelems;
#1456 if(nelems == 0)
#1494  const size_t *start, size_t nelems, const int *value)
#1497 size_t remaining = varp->xsz * nelems;
#1501 if(nelems == 0)
#1539  const size_t *start, size_t nelems, const float *value)
#1542 size_t remaining = varp->xsz * nelems;
#1546 if(nelems == 0)
#1584  const size_t *start, size_t nelems, const double *value)
#1587 size_t remaining = varp->xsz * nelems;
#1591 if(nelems == 0)
#1629  const size_t *start, size_t nelems, const longlong *value)
#1632 size_t remaining = varp->xsz * nelems;
#1636 if(nelems == 0)
#1674  const size_t *start, size_t nelems, const ushort *value)
#1677 size_t remaining = varp->xsz * nelems;
#1681 if(nelems == 0)
#1719  const size_t *start, size_t nelems, const uint *value)
#1722 size_t remaining = varp->xsz * nelems;
#1726 if(nelems == 0)
#1764  const size_t *start, size_t nelems, const ulonglong *value)
#1767 size_t remaining = varp->xsz * nelems;
#1771 if(nelems == 0)
#1810  const size_t *start, size_t nelems, const schar *value)
#1813 size_t remaining = varp->xsz * nelems;
#1817 if(nelems == 0)
#1855  const size_t *start, size_t nelems, const uchar *value)
#1858 size_t remaining = varp->xsz * nelems;
#1862 if(nelems == 0)
#1900  const size_t *start, size_t nelems, const short *value)
#1903 size_t remaining = varp->xsz * nelems;
#1907 if(nelems == 0)
#1945  const size_t *start, size_t nelems, const int *value)
#1948 size_t remaining = varp->xsz * nelems;
#1952 if(nelems == 0)
#1990  const size_t *start, size_t nelems, const float *value)
#1993 size_t remaining = varp->xsz * nelems;
#1997 if(nelems == 0)
#2035  const size_t *start, size_t nelems, const double *value)
#2038 size_t remaining = varp->xsz * nelems;
#2042 if(nelems == 0)
#2080  const size_t *start, size_t nelems, const longlong *value)
#2083 size_t remaining = varp->xsz * nelems;
#2087 if(nelems == 0)
#2125  const size_t *start, size_t nelems, const ushort *value)
#2128 size_t remaining = varp->xsz * nelems;
#2132 if(nelems == 0)
#2170  const size_t *start, size_t nelems, const uint *value)
#2173 size_t remaining = varp->xsz * nelems;
#2177 if(nelems == 0)
#2215  const size_t *start, size_t nelems, const ulonglong *value)
#2218 size_t remaining = varp->xsz * nelems;
#2222 if(nelems == 0)
#2261  const size_t *start, size_t nelems, const schar *value)
#2264 size_t remaining = varp->xsz * nelems;
#2268 if(nelems == 0)
#2306  const size_t *start, size_t nelems, const uchar *value)
#2309 size_t remaining = varp->xsz * nelems;
#2313 if(nelems == 0)
#2351  const size_t *start, size_t nelems, const short *value)
#2354 size_t remaining = varp->xsz * nelems;
#2358 if(nelems == 0)
#2396  const size_t *start, size_t nelems, const int *value)
#2399 size_t remaining = varp->xsz * nelems;
#2403 if(nelems == 0)
#2441  const size_t *start, size_t nelems, const float *value)
#2444 size_t remaining = varp->xsz * nelems;
#2448 if(nelems == 0)
#2486  const size_t *start, size_t nelems, const double *value)
#2489 size_t remaining = varp->xsz * nelems;
#2493 if(nelems == 0)
#2531  const size_t *start, size_t nelems, const longlong *value)
#2534 size_t remaining = varp->xsz * nelems;
#2538 if(nelems == 0)
#2576  const size_t *start, size_t nelems, const ushort *value)
#2579 size_t remaining = varp->xsz * nelems;
#2583 if(nelems == 0)
#2621  const size_t *start, size_t nelems, const uint *value)
#2624 size_t remaining = varp->xsz * nelems;
#2628 if(nelems == 0)
#2666  const size_t *start, size_t nelems, const ulonglong *value)
#2669 size_t remaining = varp->xsz * nelems;
#2673 if(nelems == 0)
#2712  const size_t *start, size_t nelems, const schar *value)
#2715 size_t remaining = varp->xsz * nelems;
#2719 if(nelems == 0)
#2757  const size_t *start, size_t nelems, const uchar *value)
#2760 size_t remaining = varp->xsz * nelems;
#2764 if(nelems == 0)
#2802  const size_t *start, size_t nelems, const short *value)
#2805 size_t remaining = varp->xsz * nelems;
#2809 if(nelems == 0)
#2847  const size_t *start, size_t nelems, const int *value)
#2850 size_t remaining = varp->xsz * nelems;
#2854 if(nelems == 0)
#2892  const size_t *start, size_t nelems, const float *value)
#2895 size_t remaining = varp->xsz * nelems;
#2899 if(nelems == 0)
#2937  const size_t *start, size_t nelems, const double *value)
#2940 size_t remaining = varp->xsz * nelems;
#2944 if(nelems == 0)
#2982  const size_t *start, size_t nelems, const longlong *value)
#2985 size_t remaining = varp->xsz * nelems;
#2989 if(nelems == 0)
#3027  const size_t *start, size_t nelems, const ushort *value)
#3030 size_t remaining = varp->xsz * nelems;
#3034 if(nelems == 0)
#3072  const size_t *start, size_t nelems, const uint *value)
#3075 size_t remaining = varp->xsz * nelems;
#3079 if(nelems == 0)
#3117  const size_t *start, size_t nelems, const ulonglong *value)
#3120 size_t remaining = varp->xsz * nelems;
#3124 if(nelems == 0)
#3163  const size_t *start, size_t nelems, const schar *value)
#3166 size_t remaining = varp->xsz * nelems;
#3170 if(nelems == 0)
#3208  const size_t *start, size_t nelems, const uchar *value)
#3211 size_t remaining = varp->xsz * nelems;
#3215 if(nelems == 0)
#3253  const size_t *start, size_t nelems, const short *value)
#3256 size_t remaining = varp->xsz * nelems;
#3260 if(nelems == 0)
#3298  const size_t *start, size_t nelems, const int *value)
#3301 size_t remaining = varp->xsz * nelems;
#3305 if(nelems == 0)
#3343  const size_t *start, size_t nelems, const float *value)
#3346 size_t remaining = varp->xsz * nelems;
#3350 if(nelems == 0)
#3388  const size_t *start, size_t nelems, const double *value)
#3391 size_t remaining = varp->xsz * nelems;
#3395 if(nelems == 0)
#3433  const size_t *start, size_t nelems, const longlong *value)
#3436 size_t remaining = varp->xsz * nelems;
#3440 if(nelems == 0)
#3478  const size_t *start, size_t nelems, const ushort *value)
#3481 size_t remaining = varp->xsz * nelems;
#3485 if(nelems == 0)
#3523  const size_t *start, size_t nelems, const uint *value)
#3526 size_t remaining = varp->xsz * nelems;
#3530 if(nelems == 0)
#3568  const size_t *start, size_t nelems, const ulonglong *value)
#3571 size_t remaining = varp->xsz * nelems;
#3575 if(nelems == 0)
#3614  const size_t *start, size_t nelems, const schar *value)
#3617 size_t remaining = varp->xsz * nelems;
#3621 if(nelems == 0)
#3659  const size_t *start, size_t nelems, const uchar *value)
#3662 size_t remaining = varp->xsz * nelems;
#3666 if(nelems == 0)
#3704  const size_t *start, size_t nelems, const short *value)
#3707 size_t remaining = varp->xsz * nelems;
#3711 if(nelems == 0)
#3749  const size_t *start, size_t nelems, const int *value)
#3752 size_t remaining = varp->xsz * nelems;
#3756 if(nelems == 0)
#3794  const size_t *start, size_t nelems, const float *value)
#3797 size_t remaining = varp->xsz * nelems;
#3801 if(nelems == 0)
#3839  const size_t *start, size_t nelems, const double *value)
#3842 size_t remaining = varp->xsz * nelems;
#3846 if(nelems == 0)
#3884  const size_t *start, size_t nelems, const longlong *value)
#3887 size_t remaining = varp->xsz * nelems;
#3891 if(nelems == 0)
#3929  const size_t *start, size_t nelems, const ushort *value)
#3932 size_t remaining = varp->xsz * nelems;
#3936 if(nelems == 0)
#3974  const size_t *start, size_t nelems, const uint *value)
#3977 size_t remaining = varp->xsz * nelems;
#3981 if(nelems == 0)
#4019  const size_t *start, size_t nelems, const ulonglong *value)
#4022 size_t remaining = varp->xsz * nelems;
#4026 if(nelems == 0)
#4065  const size_t *start, size_t nelems, const schar *value)
#4068 size_t remaining = varp->xsz * nelems;
#4072 if(nelems == 0)
#4110  const size_t *start, size_t nelems, const uchar *value)
#4113 size_t remaining = varp->xsz * nelems;
#4117 if(nelems == 0)
#4155  const size_t *start, size_t nelems, const short *value)
#4158 size_t remaining = varp->xsz * nelems;
#4162 if(nelems == 0)
#4200  const size_t *start, size_t nelems, const int *value)
#4203 size_t remaining = varp->xsz * nelems;
#4207 if(nelems == 0)
#4245  const size_t *start, size_t nelems, const float *value)
#4248 size_t remaining = varp->xsz * nelems;
#4252 if(nelems == 0)
#4290  const size_t *start, size_t nelems, const double *value)
#4293 size_t remaining = varp->xsz * nelems;
#4297 if(nelems == 0)
#4335  const size_t *start, size_t nelems, const longlong *value)
#4338 size_t remaining = varp->xsz * nelems;
#4342 if(nelems == 0)
#4380  const size_t *start, size_t nelems, const ushort *value)
#4383 size_t remaining = varp->xsz * nelems;
#4387 if(nelems == 0)
#4425  const size_t *start, size_t nelems, const uint *value)
#4428 size_t remaining = varp->xsz * nelems;
#4432 if(nelems == 0)
#4470  const size_t *start, size_t nelems, const ulonglong *value)
#4473 size_t remaining = varp->xsz * nelems;
#4477 if(nelems == 0)
#4516  const size_t *start, size_t nelems, const schar *value)
#4519 size_t remaining = varp->xsz * nelems;
#4523 if(nelems == 0)
#4561  const size_t *start, size_t nelems, const uchar *value)
#4564 size_t remaining = varp->xsz * nelems;
#4568 if(nelems == 0)
#4606  const size_t *start, size_t nelems, const short *value)
#4609 size_t remaining = varp->xsz * nelems;
#4613 if(nelems == 0)
#4651  const size_t *start, size_t nelems, const int *value)
#4654 size_t remaining = varp->xsz * nelems;
#4658 if(nelems == 0)
#4696  const size_t *start, size_t nelems, const float *value)
#4699 size_t remaining = varp->xsz * nelems;
#4703 if(nelems == 0)
#4741  const size_t *start, size_t nelems, const double *value)
#4744 size_t remaining = varp->xsz * nelems;
#4748 if(nelems == 0)
#4786  const size_t *start, size_t nelems, const longlong *value)
#4789 size_t remaining = varp->xsz * nelems;
#4793 if(nelems == 0)
#4831  const size_t *start, size_t nelems, const ushort *value)
#4834 size_t remaining = varp->xsz * nelems;
#4838 if(nelems == 0)
#4876  const size_t *start, size_t nelems, const uint *value)
#4879 size_t remaining = varp->xsz * nelems;
#4883 if(nelems == 0)
#4921  const size_t *start, size_t nelems, const ulonglong *value)
#4924 size_t remaining = varp->xsz * nelems;
#4928 if(nelems == 0)
#4967  const size_t *start, size_t nelems, const schar *value)
#4970 size_t remaining = varp->xsz * nelems;
#4974 if(nelems == 0)
#5012  const size_t *start, size_t nelems, const uchar *value)
#5015 size_t remaining = varp->xsz * nelems;
#5019 if(nelems == 0)
#5057  const size_t *start, size_t nelems, const short *value)
#5060 size_t remaining = varp->xsz * nelems;
#5064 if(nelems == 0)
#5102  const size_t *start, size_t nelems, const int *value)
#5105 size_t remaining = varp->xsz * nelems;
#5109 if(nelems == 0)
#5147  const size_t *start, size_t nelems, const float *value)
#5150 size_t remaining = varp->xsz * nelems;
#5154 if(nelems == 0)
#5192  const size_t *start, size_t nelems, const double *value)
#5195 size_t remaining = varp->xsz * nelems;
#5199 if(nelems == 0)
#5237  const size_t *start, size_t nelems, const longlong *value)
#5240 size_t remaining = varp->xsz * nelems;
#5244 if(nelems == 0)
#5282  const size_t *start, size_t nelems, const ushort *value)
#5285 size_t remaining = varp->xsz * nelems;
#5289 if(nelems == 0)
#5327  const size_t *start, size_t nelems, const uint *value)
#5330 size_t remaining = varp->xsz * nelems;
#5334 if(nelems == 0)
#5372  const size_t *start, size_t nelems, const ulonglong *value)
#5375 size_t remaining = varp->xsz * nelems;
#5379 if(nelems == 0)
#5419  const size_t *start, size_t nelems, char *value)
#5422 size_t remaining = varp->xsz * nelems;
#5426 if(nelems == 0)
#5460  const size_t *start, size_t nelemsschar *value)
#5463 size_t remaining = varp->xsz * nelems;
#5467 if(nelems == 0)
#5500  const size_t *start, size_t nelems, short *value)
#5503 size_t remaining = varp->xsz * nelems;
#5507 if(nelems == 0)
#5540  const size_t *start, size_t nelems, int *value)
#5543 size_t remaining = varp->xsz * nelems;
#5547 if(nelems == 0)
#5580  const size_t *start, size_t nelems, float *value)
#5583 size_t remaining = varp->xsz * nelems;
#5587 if(nelems == 0)
#5620  const size_t *start, size_t nelems, double *value)
#5623 size_t remaining = varp->xsz * nelems;
#5627 if(nelems == 0)
#5660  const size_t *start, size_t nelemslonglong *value)
#5663 size_t remaining = varp->xsz * nelems;
#5667 if(nelems == 0)
#5700  const size_t *start, size_t nelemsuint *value)
#5703 size_t remaining = varp->xsz * nelems;
#5707 if(nelems == 0)
#5740  const size_t *start, size_t nelemsulonglong *value)
#5743 size_t remaining = varp->xsz * nelems;
#5747 if(nelems == 0)
#5780  const size_t *start, size_t nelemsuchar *value)
#5783 size_t remaining = varp->xsz * nelems;
#5787 if(nelems == 0)
#5820  const size_t *start, size_t nelemsushort *value)
#5823 size_t remaining = varp->xsz * nelems;
#5827 if(nelems == 0)
#5861  const size_t *start, size_t nelemsschar *value)
#5864 size_t remaining = varp->xsz * nelems;
#5868 if(nelems == 0)
#5901  const size_t *start, size_t nelemsuchar *value)
#5904 size_t remaining = varp->xsz * nelems;
#5908 if(nelems == 0)
#5941  const size_t *start, size_t nelems, short *value)
#5944 size_t remaining = varp->xsz * nelems;
#5948 if(nelems == 0)
#5981  const size_t *start, size_t nelems, int *value)
#5984 size_t remaining = varp->xsz * nelems;
#5988 if(nelems == 0)
#6021  const size_t *start, size_t nelems, float *value)
#6024 size_t remaining = varp->xsz * nelems;
#6028 if(nelems == 0)
#6061  const size_t *start, size_t nelems, double *value)
#6064 size_t remaining = varp->xsz * nelems;
#6068 if(nelems == 0)
#6101  const size_t *start, size_t nelemslonglong *value)
#6104 size_t remaining = varp->xsz * nelems;
#6108 if(nelems == 0)
#6141  const size_t *start, size_t nelemsuint *value)
#6144 size_t remaining = varp->xsz * nelems;
#6148 if(nelems == 0)
#6181  const size_t *start, size_t nelemsulonglong *value)
#6184 size_t remaining = varp->xsz * nelems;
#6188 if(nelems == 0)
#6221  const size_t *start, size_t nelemsushort *value)
#6224 size_t remaining = varp->xsz * nelems;
#6228 if(nelems == 0)
#6262  const size_t *start, size_t nelemsschar *value)
#6265 size_t remaining = varp->xsz * nelems;
#6269 if(nelems == 0)
#6302  const size_t *start, size_t nelemsuchar *value)
#6305 size_t remaining = varp->xsz * nelems;
#6309 if(nelems == 0)
#6342  const size_t *start, size_t nelems, short *value)
#6345 size_t remaining = varp->xsz * nelems;
#6349 if(nelems == 0)
#6382  const size_t *start, size_t nelems, int *value)
#6385 size_t remaining = varp->xsz * nelems;
#6389 if(nelems == 0)
#6422  const size_t *start, size_t nelems, float *value)
#6425 size_t remaining = varp->xsz * nelems;
#6429 if(nelems == 0)
#6462  const size_t *start, size_t nelems, double *value)
#6465 size_t remaining = varp->xsz * nelems;
#6469 if(nelems == 0)
#6502  const size_t *start, size_t nelemslonglong *value)
#6505 size_t remaining = varp->xsz * nelems;
#6509 if(nelems == 0)
#6542  const size_t *start, size_t nelemsuint *value)
#6545 size_t remaining = varp->xsz * nelems;
#6549 if(nelems == 0)
#6582  const size_t *start, size_t nelemsulonglong *value)
#6585 size_t remaining = varp->xsz * nelems;
#6589 if(nelems == 0)
#6622  const size_t *start, size_t nelemsushort *value)
#6625 size_t remaining = varp->xsz * nelems;
#6629 if(nelems == 0)
#6663  const size_t *start, size_t nelemsschar *value)
#6666 size_t remaining = varp->xsz * nelems;
#6670 if(nelems == 0)
#6703  const size_t *start, size_t nelemsuchar *value)
#6706 size_t remaining = varp->xsz * nelems;
#6710 if(nelems == 0)
#6743  const size_t *start, size_t nelems, short *value)
#6746 size_t remaining = varp->xsz * nelems;
#6750 if(nelems == 0)
#6783  const size_t *start, size_t nelems, int *value)
#6786 size_t remaining = varp->xsz * nelems;
#6790 if(nelems == 0)
#6823  const size_t *start, size_t nelems, float *value)
#6826 size_t remaining = varp->xsz * nelems;
#6830 if(nelems == 0)
#6863  const size_t *start, size_t nelems, double *value)
#6866 size_t remaining = varp->xsz * nelems;
#6870 if(nelems == 0)
#6903  const size_t *start, size_t nelemslonglong *value)
#6906 size_t remaining = varp->xsz * nelems;
#6910 if(nelems == 0)
#6943  const size_t *start, size_t nelemsuint *value)
#6946 size_t remaining = varp->xsz * nelems;
#6950 if(nelems == 0)
#6983  const size_t *start, size_t nelemsulonglong *value)
#6986 size_t remaining = varp->xsz * nelems;
#6990 if(nelems == 0)
#7023  const size_t *start, size_t nelemsushort *value)
#7026 size_t remaining = varp->xsz * nelems;
#7030 if(nelems == 0)
#7064  const size_t *start, size_t nelemsschar *value)
#7067 size_t remaining = varp->xsz * nelems;
#7071 if(nelems == 0)
#7104  const size_t *start, size_t nelemsuchar *value)
#7107 size_t remaining = varp->xsz * nelems;
#7111 if(nelems == 0)
#7144  const size_t *start, size_t nelems, short *value)
#7147 size_t remaining = varp->xsz * nelems;
#7151 if(nelems == 0)
#7184  const size_t *start, size_t nelems, int *value)
#7187 size_t remaining = varp->xsz * nelems;
#7191 if(nelems == 0)
#7224  const size_t *start, size_t nelems, float *value)
#7227 size_t remaining = varp->xsz * nelems;
#7231 if(nelems == 0)
#7264  const size_t *start, size_t nelems, double *value)
#7267 size_t remaining = varp->xsz * nelems;
#7271 if(nelems == 0)
#7304  const size_t *start, size_t nelemslonglong *value)
#7307 size_t remaining = varp->xsz * nelems;
#7311 if(nelems == 0)
#7344  const size_t *start, size_t nelemsuint *value)
#7347 size_t remaining = varp->xsz * nelems;
#7351 if(nelems == 0)
#7384  const size_t *start, size_t nelemsulonglong *value)
#7387 size_t remaining = varp->xsz * nelems;
#7391 if(nelems == 0)
#7424  const size_t *start, size_t nelemsushort *value)
#7427 size_t remaining = varp->xsz * nelems;
#7431 if(nelems == 0)
#7465  const size_t *start, size_t nelemsschar *value)
#7468 size_t remaining = varp->xsz * nelems;
#7472 if(nelems == 0)
#7505  const size_t *start, size_t nelemsuchar *value)
#7508 size_t remaining = varp->xsz * nelems;
#7512 if(nelems == 0)
#7545  const size_t *start, size_t nelems, short *value)
#7548 size_t remaining = varp->xsz * nelems;
#7552 if(nelems == 0)
#7585  const size_t *start, size_t nelems, int *value)
#7588 size_t remaining = varp->xsz * nelems;
#7592 if(nelems == 0)
#7625  const size_t *start, size_t nelems, float *value)
#7628 size_t remaining = varp->xsz * nelems;
#7632 if(nelems == 0)
#7665  const size_t *start, size_t nelems, double *value)
#7668 size_t remaining = varp->xsz * nelems;
#7672 if(nelems == 0)
#7705  const size_t *start, size_t nelemslonglong *value)
#7708 size_t remaining = varp->xsz * nelems;
#7712 if(nelems == 0)
#7745  const size_t *start, size_t nelemsuint *value)
#7748 size_t remaining = varp->xsz * nelems;
#7752 if(nelems == 0)
#7785  const size_t *start, size_t nelemsulonglong *value)
#7788 size_t remaining = varp->xsz * nelems;
#7792 if(nelems == 0)
#7825  const size_t *start, size_t nelemsushort *value)
#7828 size_t remaining = varp->xsz * nelems;
#7832 if(nelems == 0)
#7866  const size_t *start, size_t nelemsschar *value)
#7869 size_t remaining = varp->xsz * nelems;
#7873 if(nelems == 0)
#7906  const size_t *start, size_t nelemsuchar *value)
#7909 size_t remaining = varp->xsz * nelems;
#7913 if(nelems == 0)
#7946  const size_t *start, size_t nelems, short *value)
#7949 size_t remaining = varp->xsz * nelems;
#7953 if(nelems == 0)
#7986  const size_t *start, size_t nelems, int *value)
#7989 size_t remaining = varp->xsz * nelems;
#7993 if(nelems == 0)
#8026  const size_t *start, size_t nelems, float *value)
#8029 size_t remaining = varp->xsz * nelems;
#8033 if(nelems == 0)
#8066  const size_t *start, size_t nelems, double *value)
#8069 size_t remaining = varp->xsz * nelems;
#8073 if(nelems == 0)
#8106  const size_t *start, size_t nelemslonglong *value)
#8109 size_t remaining = varp->xsz * nelems;
#8113 if(nelems == 0)
#8146  const size_t *start, size_t nelemsuint *value)
#8149 size_t remaining = varp->xsz * nelems;
#8153 if(nelems == 0)
#8186  const size_t *start, size_t nelemsulonglong *value)
#8189 size_t remaining = varp->xsz * nelems;
#8193 if(nelems == 0)
#8226  const size_t *start, size_t nelemsushort *value)
#8229 size_t remaining = varp->xsz * nelems;
#8233 if(nelems == 0)
#8267  const size_t *start, size_t nelemsschar *value)
#8270 size_t remaining = varp->xsz * nelems;
#8274 if(nelems == 0)
#8307  const size_t *start, size_t nelemsuchar *value)
#8310 size_t remaining = varp->xsz * nelems;
#8314 if(nelems == 0)
#8347  const size_t *start, size_t nelems, short *value)
#8350 size_t remaining = varp->xsz * nelems;
#8354 if(nelems == 0)
#8387  const size_t *start, size_t nelems, int *value)
#8390 size_t remaining = varp->xsz * nelems;
#8394 if(nelems == 0)
#8427  const size_t *start, size_t nelems, float *value)
#8430 size_t remaining = varp->xsz * nelems;
#8434 if(nelems == 0)
#8467  const size_t *start, size_t nelems, double *value)
#8470 size_t remaining = varp->xsz * nelems;
#8474 if(nelems == 0)
#8507  const size_t *start, size_t nelemslonglong *value)
#8510 size_t remaining = varp->xsz * nelems;
#8514 if(nelems == 0)
#8547  const size_t *start, size_t nelemsuint *value)
#8550 size_t remaining = varp->xsz * nelems;
#8554 if(nelems == 0)
#8587  const size_t *start, size_t nelemsulonglong *value)
#8590 size_t remaining = varp->xsz * nelems;
#8594 if(nelems == 0)
#8627  const size_t *start, size_t nelemsushort *value)
#8630 size_t remaining = varp->xsz * nelems;
#8634 if(nelems == 0)
#8668  const size_t *start, size_t nelemsschar *value)
#8671 size_t remaining = varp->xsz * nelems;
#8675 if(nelems == 0)
#8708  const size_t *start, size_t nelemsuchar *value)
#8711 size_t remaining = varp->xsz * nelems;
#8715 if(nelems == 0)
#8748  const size_t *start, size_t nelems, short *value)
#8751 size_t remaining = varp->xsz * nelems;
#8755 if(nelems == 0)
#8788  const size_t *start, size_t nelems, int *value)
#8791 size_t remaining = varp->xsz * nelems;
#8795 if(nelems == 0)
#8828  const size_t *start, size_t nelems, float *value)
#8831 size_t remaining = varp->xsz * nelems;
#8835 if(nelems == 0)
#8868  const size_t *start, size_t nelems, double *value)
#8871 size_t remaining = varp->xsz * nelems;
#8875 if(nelems == 0)
#8908  const size_t *start, size_t nelemslonglong *value)
#8911 size_t remaining = varp->xsz * nelems;
#8915 if(nelems == 0)
#8948  const size_t *start, size_t nelemsuint *value)
#8951 size_t remaining = varp->xsz * nelems;
#8955 if(nelems == 0)
#8988  const size_t *start, size_t nelemsulonglong *value)
#8991 size_t remaining = varp->xsz * nelems;
#8995 if(nelems == 0)
#9028  const size_t *start, size_t nelemsushort *value)
#9031 size_t remaining = varp->xsz * nelems;
#9035 if(nelems == 0)
#9069  const size_t *start, size_t nelemsschar *value)
#9072 size_t remaining = varp->xsz * nelems;
#9076 if(nelems == 0)
#9109  const size_t *start, size_t nelemsuchar *value)
#9112 size_t remaining = varp->xsz * nelems;
#9116 if(nelems == 0)
#9149  const size_t *start, size_t nelems, short *value)
#9152 size_t remaining = varp->xsz * nelems;
#9156 if(nelems == 0)
#9189  const size_t *start, size_t nelems, int *value)
#9192 size_t remaining = varp->xsz * nelems;
#9196 if(nelems == 0)
#9229  const size_t *start, size_t nelems, float *value)
#9232 size_t remaining = varp->xsz * nelems;
#9236 if(nelems == 0)
#9269  const size_t *start, size_t nelems, double *value)
#9272 size_t remaining = varp->xsz * nelems;
#9276 if(nelems == 0)
#9309  const size_t *start, size_t nelemslonglong *value)
#9312 size_t remaining = varp->xsz * nelems;
#9316 if(nelems == 0)
#9349  const size_t *start, size_t nelemsuint *value)
#9352 size_t remaining = varp->xsz * nelems;
#9356 if(nelems == 0)
#9389  const size_t *start, size_t nelemsulonglong *value)
#9392 size_t remaining = varp->xsz * nelems;
#9396 if(nelems == 0)
#9429  const size_t *start, size_t nelemsushort *value)
#9432 size_t remaining = varp->xsz * nelems;
#9436 if(nelems == 0)
#9471  const size_t *start, size_t nelemsuchar *value)
#9474 size_t remaining = varp->xsz * nelems;
#9478 if(nelems == 0)
#9660        const size_t nelems, void* value, const nc_type memtype)
#9668       return getNCvx_char_char(ncp,varp,start,nelems,(char*)value);
#9670    return getNCvx_schar_schar(ncp,varp,start,nelems,(signed char*)value);
#9674        return getNCvx_schar_schar(ncp,varp,start,nelems,(signed char*)value);
#9677        return getNCvx_schar_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#9680        return getNCvx_schar_short(ncp,varp,start,nelems,(short*)value);
#9683        return getNCvx_schar_int(ncp,varp,start,nelems,(int*)value);
#9686        return getNCvx_schar_float(ncp,varp,start,nelems,(float*)value);
#9689        return getNCvx_schar_double(ncp,varp,start,nelems,(double *)value);
#9692        return getNCvx_schar_longlong(ncp,varp,start,nelems,(long long*)value);
#9695        return getNCvx_schar_uint(ncp,varp,start,nelems,(unsigned int*)value);
#9698        return getNCvx_schar_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#9701        return getNCvx_schar_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#9704        return getNCvx_short_schar(ncp,varp,start,nelems,(signed char*)value);
#9707        return getNCvx_short_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#9710        return getNCvx_short_short(ncp,varp,start,nelems,(short*)value);
#9713        return getNCvx_short_int(ncp,varp,start,nelems,(int*)value);
#9716        return getNCvx_short_float(ncp,varp,start,nelems,(float*)value);
#9719        return getNCvx_short_double(ncp,varp,start,nelems,(double*)value);
#9722        return getNCvx_short_longlong(ncp,varp,start,nelems,(long long*)value);
#9725        return getNCvx_short_uint(ncp,varp,start,nelems,(unsigned int*)value);
#9728        return getNCvx_short_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#9731        return getNCvx_short_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#9735        return getNCvx_int_schar(ncp,varp,start,nelems,(signed char*)value);
#9738        return getNCvx_int_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#9741        return getNCvx_int_short(ncp,varp,start,nelems,(short*)value);
#9744        return getNCvx_int_int(ncp,varp,start,nelems,(int*)value);
#9747        return getNCvx_int_float(ncp,varp,start,nelems,(float*)value);
#9750        return getNCvx_int_double(ncp,varp,start,nelems,(double*)value);
#9753        return getNCvx_int_longlong(ncp,varp,start,nelems,(long long*)value);
#9756        return getNCvx_int_uint(ncp,varp,start,nelems,(unsigned int*)value);
#9759        return getNCvx_int_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#9762        return getNCvx_int_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#9766        return getNCvx_float_schar(ncp,varp,start,nelems,(signed char*)value);
#9769        return getNCvx_float_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#9772        return getNCvx_float_short(ncp,varp,start,nelems,(short*)value);
#9775        return getNCvx_float_int(ncp,varp,start,nelems,(int*)value);
#9778        return getNCvx_float_float(ncp,varp,start,nelems,(float*)value);
#9781        return getNCvx_float_double(ncp,varp,start,nelems,(double*)value);
#9784        return getNCvx_float_longlong(ncp,varp,start,nelems,(long long*)value);
#9787        return getNCvx_float_uint(ncp,varp,start,nelems,(unsigned int*)value);
#9790        return getNCvx_float_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#9793        return getNCvx_float_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#9797        return getNCvx_double_schar(ncp,varp,start,nelems,(signed char*)value);
#9800        return getNCvx_double_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#9803        return getNCvx_double_short(ncp,varp,start,nelems,(short*)value);
#9806        return getNCvx_double_int(ncp,varp,start,nelems,(int*)value);
#9809        return getNCvx_double_float(ncp,varp,start,nelems,(float*)value);
#9812        return getNCvx_double_double(ncp,varp,start,nelems,(double*)value);
#9815        return getNCvx_double_longlong(ncp,varp,start,nelems,(long long*)value);
#9818        return getNCvx_double_uint(ncp,varp,start,nelems,(unsigned int*)value);
#9821        return getNCvx_double_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#9824        return getNCvx_double_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#9828        return getNCvx_uchar_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#9831        return getNCvx_uchar_schar(ncp,varp,start,nelems,(signed char*)value);
#9834        return getNCvx_uchar_short(ncp,varp,start,nelems,(short*)value);
#9837        return getNCvx_uchar_int(ncp,varp,start,nelems,(int*)value);
#9840        return getNCvx_uchar_float(ncp,varp,start,nelems,(float*)value);
#9843        return getNCvx_uchar_double(ncp,varp,start,nelems,(double *)value);
#9846        return getNCvx_uchar_longlong(ncp,varp,start,nelems,(long long*)value);
#9849        return getNCvx_uchar_uint(ncp,varp,start,nelems,(unsigned int*)value);
#9852        return getNCvx_uchar_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#9855        return getNCvx_uchar_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#9859        return getNCvx_ushort_schar(ncp,varp,start,nelems,(signed char*)value);
#9862        return getNCvx_ushort_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#9865        return getNCvx_ushort_short(ncp,varp,start,nelems,(short*)value);
#9868        return getNCvx_ushort_int(ncp,varp,start,nelems,(int*)value);
#9871        return getNCvx_ushort_float(ncp,varp,start,nelems,(float*)value);
#9874        return getNCvx_ushort_double(ncp,varp,start,nelems,(double*)value);
#9877        return getNCvx_ushort_longlong(ncp,varp,start,nelems,(long long*)value);
#9880        return getNCvx_ushort_uint(ncp,varp,start,nelems,(unsigned int*)value);
#9883        return getNCvx_ushort_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#9886        return getNCvx_ushort_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#9890        return getNCvx_uint_schar(ncp,varp,start,nelems,(signed char*)value);
#9893        return getNCvx_uint_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#9896        return getNCvx_uint_short(ncp,varp,start,nelems,(short*)value);
#9899        return getNCvx_uint_int(ncp,varp,start,nelems,(int*)value);
#9902        return getNCvx_uint_float(ncp,varp,start,nelems,(float*)value);
#9905        return getNCvx_uint_double(ncp,varp,start,nelems,(double*)value);
#9908        return getNCvx_uint_longlong(ncp,varp,start,nelems,(long long*)value);
#9911        return getNCvx_uint_uint(ncp,varp,start,nelems,(unsigned int*)value);
#9914        return getNCvx_uint_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#9917        return getNCvx_uint_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#9921        return getNCvx_longlong_schar(ncp,varp,start,nelems,(signed char*)value);
#9924        return getNCvx_longlong_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#9927        return getNCvx_longlong_short(ncp,varp,start,nelems,(short*)value);
#9930        return getNCvx_longlong_int(ncp,varp,start,nelems,(int*)value);
#9933        return getNCvx_longlong_float(ncp,varp,start,nelems,(float*)value);
#9936        return getNCvx_longlong_double(ncp,varp,start,nelems,(double*)value);
#9939        return getNCvx_longlong_longlong(ncp,varp,start,nelems,(long long*)value);
#9942        return getNCvx_longlong_uint(ncp,varp,start,nelems,(unsigned int*)value);
#9945        return getNCvx_longlong_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#9948        return getNCvx_longlong_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#9952        return getNCvx_ulonglong_schar(ncp,varp,start,nelems,(signed char*)value);
#9955        return getNCvx_ulonglong_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#9958        return getNCvx_ulonglong_short(ncp,varp,start,nelems,(short*)value);
#9961        return getNCvx_ulonglong_int(ncp,varp,start,nelems,(int*)value);
#9964        return getNCvx_ulonglong_float(ncp,varp,start,nelems,(float*)value);
#9967        return getNCvx_ulonglong_double(ncp,varp,start,nelems,(double*)value);
#9970        return getNCvx_ulonglong_longlong(ncp,varp,start,nelems,(long long*)value);
#9973        return getNCvx_ulonglong_uint(ncp,varp,start,nelems,(unsigned int*)value);
#9976        return getNCvx_ulonglong_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#9979        return getNCvx_ulonglong_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#9992         const size_t nelems, const void* value, const nc_type memtype)
#9999        return putNCvx_char_char(ncp,varp,start,nelems,(char*)value);
#10002        return putNCvx_schar_schar(ncp,varp,start,nelems,(signed char*)value);
#10005        return putNCvx_schar_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#10008        return putNCvx_schar_short(ncp,varp,start,nelems,(short*)value);
#10011        return putNCvx_schar_int(ncp,varp,start,nelems,(int*)value);
#10014        return putNCvx_schar_float(ncp,varp,start,nelems,(float*)value);
#10017        return putNCvx_schar_double(ncp,varp,start,nelems,(double *)value);
#10020        return putNCvx_schar_longlong(ncp,varp,start,nelems,(long long*)value);
#10023        return putNCvx_schar_uint(ncp,varp,start,nelems,(unsigned int*)value);
#10026        return putNCvx_schar_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#10029        return putNCvx_schar_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#10032        return putNCvx_short_schar(ncp,varp,start,nelems,(signed char*)value);
#10035        return putNCvx_short_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#10038        return putNCvx_short_short(ncp,varp,start,nelems,(short*)value);
#10041        return putNCvx_short_int(ncp,varp,start,nelems,(int*)value);
#10044        return putNCvx_short_float(ncp,varp,start,nelems,(float*)value);
#10047        return putNCvx_short_double(ncp,varp,start,nelems,(double*)value);
#10050        return putNCvx_short_longlong(ncp,varp,start,nelems,(long long*)value);
#10053        return putNCvx_short_uint(ncp,varp,start,nelems,(unsigned int*)value);
#10056        return putNCvx_short_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#10059        return putNCvx_short_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#10062        return putNCvx_int_schar(ncp,varp,start,nelems,(signed char*)value);
#10065        return putNCvx_int_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#10068        return putNCvx_int_short(ncp,varp,start,nelems,(short*)value);
#10071        return putNCvx_int_int(ncp,varp,start,nelems,(int*)value);
#10074        return putNCvx_int_float(ncp,varp,start,nelems,(float*)value);
#10077        return putNCvx_int_double(ncp,varp,start,nelems,(double*)value);
#10080        return putNCvx_int_longlong(ncp,varp,start,nelems,(long long*)value);
#10083        return putNCvx_int_uint(ncp,varp,start,nelems,(unsigned int*)value);
#10086        return putNCvx_int_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#10089        return putNCvx_int_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#10092        return putNCvx_float_schar(ncp,varp,start,nelems,(signed char*)value);
#10095        return putNCvx_float_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#10098        return putNCvx_float_short(ncp,varp,start,nelems,(short*)value);
#10101        return putNCvx_float_int(ncp,varp,start,nelems,(int*)value);
#10104        return putNCvx_float_float(ncp,varp,start,nelems,(float*)value);
#10107        return putNCvx_float_double(ncp,varp,start,nelems,(double*)value);
#10110        return putNCvx_float_longlong(ncp,varp,start,nelems,(long long*)value);
#10113        return putNCvx_float_uint(ncp,varp,start,nelems,(unsigned int*)value);
#10116        return putNCvx_float_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#10119        return putNCvx_float_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#10122        return putNCvx_double_schar(ncp,varp,start,nelems,(signed char*)value);
#10125        return putNCvx_double_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#10128        return putNCvx_double_short(ncp,varp,start,nelems,(short*)value);
#10131        return putNCvx_double_int(ncp,varp,start,nelems,(int*)value);
#10134        return putNCvx_double_float(ncp,varp,start,nelems,(float*)value);
#10137        return putNCvx_double_double(ncp,varp,start,nelems,(double*)value);
#10140        return putNCvx_double_longlong(ncp,varp,start,nelems,(long long*)value);
#10143        return putNCvx_double_uint(ncp,varp,start,nelems,(unsigned int*)value);
#10146        return putNCvx_double_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#10149        return putNCvx_double_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#10152        return putNCvx_uchar_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#10155        return putNCvx_uchar_schar(ncp,varp,start,nelems,(signed char*)value);
#10158        return putNCvx_uchar_short(ncp,varp,start,nelems,(short*)value);
#10161        return putNCvx_uchar_int(ncp,varp,start,nelems,(int*)value);
#10164        return putNCvx_uchar_float(ncp,varp,start,nelems,(float*)value);
#10167        return putNCvx_uchar_double(ncp,varp,start,nelems,(double *)value);
#10170        return putNCvx_uchar_longlong(ncp,varp,start,nelems,(long long*)value);
#10173        return putNCvx_uchar_uint(ncp,varp,start,nelems,(unsigned int*)value);
#10176        return putNCvx_uchar_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#10179        return putNCvx_uchar_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#10182        return putNCvx_ushort_schar(ncp,varp,start,nelems,(signed char*)value);
#10185        return putNCvx_ushort_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#10188        return putNCvx_ushort_short(ncp,varp,start,nelems,(short*)value);
#10191        return putNCvx_ushort_int(ncp,varp,start,nelems,(int*)value);
#10194        return putNCvx_ushort_float(ncp,varp,start,nelems,(float*)value);
#10197        return putNCvx_ushort_double(ncp,varp,start,nelems,(double*)value);
#10200        return putNCvx_ushort_longlong(ncp,varp,start,nelems,(long long*)value);
#10203        return putNCvx_ushort_uint(ncp,varp,start,nelems,(unsigned int*)value);
#10206        return putNCvx_ushort_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#10209        return putNCvx_ushort_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#10212        return putNCvx_uint_schar(ncp,varp,start,nelems,(signed char*)value);
#10215        return putNCvx_uint_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#10218        return putNCvx_uint_short(ncp,varp,start,nelems,(short*)value);
#10221        return putNCvx_uint_int(ncp,varp,start,nelems,(int*)value);
#10224        return putNCvx_uint_float(ncp,varp,start,nelems,(float*)value);
#10227        return putNCvx_uint_double(ncp,varp,start,nelems,(double*)value);
#10230        return putNCvx_uint_longlong(ncp,varp,start,nelems,(long long*)value);
#10233        return putNCvx_uint_uint(ncp,varp,start,nelems,(unsigned int*)value);
#10236        return putNCvx_uint_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#10239        return putNCvx_uint_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#10242        return putNCvx_longlong_schar(ncp,varp,start,nelems,(signed char*)value);
#10245        return putNCvx_longlong_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#10248        return putNCvx_longlong_short(ncp,varp,start,nelems,(short*)value);
#10251        return putNCvx_longlong_int(ncp,varp,start,nelems,(int*)value);
#10254        return putNCvx_longlong_float(ncp,varp,start,nelems,(float*)value);
#10257        return putNCvx_longlong_double(ncp,varp,start,nelems,(double*)value);
#10260        return putNCvx_longlong_longlong(ncp,varp,start,nelems,(long long*)value);
#10263        return putNCvx_longlong_uint(ncp,varp,start,nelems,(unsigned int*)value);
#10266        return putNCvx_longlong_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#10269        return putNCvx_longlong_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#10272        return putNCvx_ulonglong_schar(ncp,varp,start,nelems,(signed char*)value);
#10275        return putNCvx_ulonglong_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#10278        return putNCvx_ulonglong_short(ncp,varp,start,nelems,(short*)value);
#10281        return putNCvx_ulonglong_int(ncp,varp,start,nelems,(int*)value);
#10284        return putNCvx_ulonglong_float(ncp,varp,start,nelems,(float*)value);
#10287        return putNCvx_ulonglong_double(ncp,varp,start,nelems,(double*)value);
#10290        return putNCvx_ulonglong_longlong(ncp,varp,start,nelems,(long long*)value);
#10293        return putNCvx_ulonglong_uint(ncp,varp,start,nelems,(unsigned int*)value);
#10296        return putNCvx_ulonglong_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#10299        return putNCvx_ulonglong_ushort(ncp,varp,start,nelems,(unsigned short*)value);
semantics.c#611     tsym->typ.nelems = 1; /* always a single compound datalist */
#616     tsym->typ.nelems = 1;
#620     tsym->typ.nelems = 1;
#626     tsym->typ.nelems = 1;
#663         tsym->typ.nelems = 1;
#667         tsym->typ.nelems = tsym->typ.basetype->typ.nelems;
test_nstride_cached.c#89    int nelems = XSIZE*YSIZE;
#91    float *dat = (float*)malloc(sizeof(float)*nelems);
#175    for (i=(nelems-11); i<(nelems-1); i++)
#224    for (i=(nelems-11); i<(nelems-1); i++)
v1hpg.c#469 const NC_dim *const *const end = &dpp[ncap->nelems];
#494 || ncap->nelems == 0
#516 status = v1h_put_size_t(psp, &ncap->nelems);
#522 const NC_dim *const *const end = &dpp[ncap->nelems];
#549 status = v1h_get_size_t(gsp, &ncap->nelems);
#553 if(ncap->nelems == 0)
#559 ncap->value = (NC_dim **) malloc(ncap->nelems * sizeof(NC_dim *));
#562 ncap->nalloc = ncap->nelems;
#564 ncap->hashmap = NC_hashmapCreate(ncap->nelems);
#568 NC_dim *const *const end = &dpp[ncap->nelems];
#574 ncap->nelems = (size_t)(dpp - ncap->value);
#670 status = v1h_put_size_t(psp, &attrp->nelems);
#727 size_t nelems;
#738 status = v1h_get_size_t(gsp, &nelems);
#742 attrp = new_x_NC_attr(strptypenelems);
#777 const NC_attr *const *const end = &app[ncap->nelems];
#802 || ncap->nelems == 0
#824 status = v1h_put_size_t(psp, &ncap->nelems);
#830 const NC_attr *const *const end = &app[ncap->nelems];
#856 status = v1h_get_size_t(gsp, &ncap->nelems);
#860 if(ncap->nelems == 0)
#866 ncap->value = (NC_attr **) malloc(ncap->nelems * sizeof(NC_attr *));
#869 ncap->nalloc = ncap->nelems;
#873 NC_attr *const *const end = &app[ncap->nelems];
#879 ncap->nelems = (size_t)(app - ncap->value);
#1064 const NC_var *const *const end = &vpp[ncap->nelems];
#1089 || ncap->nelems == 0
#1111 status = v1h_put_size_t(psp, &ncap->nelems);
#1117 const NC_var *const *const end = &vpp[ncap->nelems];
#1144 status = v1h_get_size_t(gsp, &ncap->nelems);
#1148 if(ncap->nelems == 0)
#1154 ncap->value = (NC_var **) malloc(ncap->nelems * sizeof(NC_var *));
#1157 ncap->nalloc = ncap->nelems;
#1159 ncap->hashmap = NC_hashmapCreate(ncap->nelems);
#1162 NC_var *const *const end = &vpp[ncap->nelems];
#1168 ncap->nelems = (size_t)(vpp - ncap->value);
#1198 NC_var *const *const end = &vpp[ncp->vars.nelems];
#1207 if(ncp->vars.nelems == 0)
var.c#194 if(ncap->nelems == 0)
#201 NC_var *const *const end = &vpp[ncap->nelems];
#208 ncap->nelems = 0;
#246 if(ref->nelems != 0)
#248 const size_t sz = ref->nelems * sizeof(NC_var *);
#253 ncap->nalloc = ref->nelems;
#256 ncap->nelems = 0;
#260 NC_var *const *const end = &vpp[ref->nelems];
#261 for( /*NADA*/; vpp < enddrpp++, vpp++, ncap->nelems++)
#278 assert(ncap->nelems == ref->nelems);
#298 assert(ncap->nelems == 0);
#307 else if(ncap->nelems +1 > ncap->nalloc)
#319 NC_hashmapAddVar(ncap, (long)ncap->nelemsnewelemp->name->cp);
#320 ncap->value[ncap->nelems] = newelemp;
#321 ncap->nelems++;
#332 if(ncap->nelems == 0 || (unsigned long)elem >= ncap->nelems)
#359 if(ncap->nelems == 0)
#445 if(*ip < 0 || (size_t) (*ip) >= ((dims != NULL) ? dims->nelems : 1) )
#603 if(ncp->vars.nelems >= NC_MAX_VARS)
#633 *varidp = (int)ncp->vars.nelems -1; /* varid */
#708 *nattsp = (int) varp->attrs.nelems;


HyperKWIC - Version 7.20DA executed at 11:37 on 27 Oct 2017 | Polyhedron Solutions - INTERNAL USE | COMMERCIAL (Any O/S) SN 4AKIed