add.c#156add_data(testvaridstartedges) /* keep max record written updated */
#159     long start[];
#164    if (start[0] + edges[0] > test->dims[test->xdimid].size)
#165      test->dims[test->xdimid].size = start[0] + edges[0];
bm_file.c#50      size_t start[MAX_DIMS], count[MAX_DIMS], inc[MAX_DIMS];
#78   size_t *last_count, size_t *start, size_t *count)
#94  start[d] = vo->start[d];
#140      start[0] = *start_inc * my_rank;
#141      if (start[0] > dimlen[0])
#145  *start_incslow_countpmy_rankstart[0]);
#151  start[d] = 0;
#269   size_t *count = NULL, *start = NULL;
#362      if (!(start = malloc(real_ndims * sizeof(size_t))))
#384    &last_countstartcount)))
#413  if (nc_get_vara(ncid1vstartcountdata)) ERR;
#421  if (nc_get_vara(ncid2vstartcountdata2)) ERR;
#440  start[0] += start_inc;
#447      if (start) free(start);
#643      size_t *count = NULL, *start = NULL;
#673      if (!(start = malloc(real_ndims * sizeof(size_t))))
#693    &last_countstartcount)))
#724  if ((ret = nc_get_vara(ncid_invstartcountdata)))
#746     if ((ret = nc_put_vara(ncid_outvstartcountdata)))
#761  start[0] += start_inc;
#772      if (start) free(start);
#934      sscanf(subtoken, "%ld", &(vo[num_vo].start[ndims++]));
#1053       dvo[v].start[d], dvo[v].count[d], dvo[v].inc[d]);
dapodom.c#25 odom->start[i] = segment->slices[i+startindex].first;
#35 odom->index[i] = odom->start[i];
#42     const size_t* start, const size_t* count,
#53 istart = (start != NULL ? start[i] : 0);
#58 odom->start[i] = istart;
#62 odom->index[i] = odom->start[i];
#86 (size_t)odom->start[i],
#123 odom->index[i] = odom->start[i]; /* reset this position*/
#137 tmp = tmp - odom->start[i];
dapodom.h#12    size_t         start[NC_MAX_VAR_DIMS];
#22extern Dapodometerdapodom_fromsegment(DCEsegmentsegment, size_t start, size_t stop);
#26                                const size_t* start, const size_t* count,
dceconstraints.c#970  size_t* start,
#979     if(start != NULLstart[i] = segment->slices[i].first;
#989dcesegmentsize(DCEsegmentseg, size_t start, size_t stop)
#993    for(count=1,i=start;i<stop;i++) {
#1008dcesafeindex(DCEsegmentseg, size_t start, size_t stop)
#1014    for(safe=stop-1;safe>start;safe--) {
#1017    return dceiswholeslice(&seg->slices[start]) ? start /*every slice is safe*/
#1018                                                 : start+1 ;
dceconstraints.h#124  size_t* start,
#135extern size_t dcesafeindex(DCEsegmentseg, size_t start, size_t stop);
#138extern size_t dcesegmentsize(DCEsegment*, size_t start, size_t stop);
dceparse.c#199    long long start = -1;
#202    sscanf((char*)indexno,"%lld",&start);
#203    if(start < 0) {
#205 start = 1;
#208    slice->first = start;
#211    slice->last = start;
dcopy.c#262   size_t *count = NULL, *start = NULL;
#335   if (!(start = malloc((size_t)real_ndims * sizeof(size_t))))
#368      start[d] = 0;
#381     if(start) free(start);
#386   for (start[0]=0; !retval && start[0]<(size_t)dimlen[0]; start[0]++)
#391     retval = nc_get_vara_schar(ncid_invarid_instartcount,
#394        retval = nc_put_vara_schar(ncid_outvarid_outstartcount,
#398     retval = nc_get_vara_text(ncid_invarid_instartcount,
#401        retval = nc_put_vara_text(ncid_outvarid_outstartcount,
#405     retval = nc_get_vara_short(ncid_invarid_instartcount,
#408        retval = nc_put_vara_short(ncid_outvarid_outstartcount,
#412     retval = nc_get_vara_int(ncid_invarid_instartcount,
#415        retval = nc_put_vara_int(ncid_outvarid_outstartcount,
#419     retval = nc_get_vara_float(ncid_invarid_instartcount,
#422        retval = nc_put_vara_float(ncid_outvarid_outstartcount,
#426     retval = nc_get_vara_double(ncid_invarid_instartcount,
#429        retval = nc_put_vara_double(ncid_outvarid_outstartcount,
#433     retval = nc_get_vara_uchar(ncid_invarid_instartcount,
#436        retval = nc_put_vara_uchar(ncid_outvarid_outstartcount,
#440     retval = nc_get_vara_ushort(ncid_invarid_instartcount,
#443        retval = nc_put_vara_ushort(ncid_outvarid_outstartcount,
#447     retval = nc_get_vara_uint(ncid_invarid_instartcount,
#450        retval = nc_put_vara_uint(ncid_outvarid_outstartcount,
#454     retval = nc_get_vara_longlong(ncid_invarid_instartcount,
#457        retval = nc_put_vara_longlong(ncid_outvarid_outstartcount,
#461     retval = nc_get_vara_ulonglong(ncid_invarid_instartcount,
#464        retval = nc_put_vara_ulonglong(ncid_outvarid_outstartcount,
#475   if (start) free(start);
dv2i.c#292    size_t start[MAX_NC_DIMS];
#302    start[0] = recnum;
#304 start[varid] = 0;
#313     status = nc_put_vara(ncidrvarids[varid], startedgesdatap[varid]);
#338    size_t start[MAX_NC_DIMS];
#348    start[0] = recnum;
#350 start[varid] = 0;
#358     status = nc_get_vara(ncidrvarids[varid], startedgesdatap[varid]);
#729    const long* start,
#735 A_DECL(stp, size_t, ndimsstart);
#737 A_INIT(stp, size_t, ndimsstart);
#757    const long* start,
#763 A_DECL(stp, size_t, ndimsstart);
#765 A_INIT(stp, size_t, ndimsstart);
#785    const long* start,
#792 return ncvarput(ncidvaridstartcountvalue);
#797 A_DECL(stp, size_t, ndimsstart);
#800 A_INIT(stp, size_t, ndimsstart);
#823    const long* start,
#830 return ncvarget(ncidvaridstartcountvalue);
#834 A_DECL(stp, size_t, ndimsstart);
#837 A_INIT(stp, size_t, ndimsstart);
#860    const long* start,
#869 return ncvarputs(ncidvaridstartcountstridevalue);
#888 A_DECL(stp, size_t, ndimsstart);
#891 A_INIT(stp, size_t, ndimsstart);
#917    const long* start,
#926 return ncvargets(ncidvaridstartcountstridevalue);
#945 A_DECL(stp, size_t, ndimsstart);
#948 A_INIT(stp, size_t, ndimsstart);
dvarget.c#21    size_t         start[NC_MAX_VAR_DIMS];
#34     const size_t* start, const size_t* edges, const ptrdiff_tstride)
#41 odom->start[i] = (start != NULL ? start[i] : 0);
#44 odom->stop[i] = odom->start[i] + (odom->edges[i]*((size_t)odom->stride[i]));
#45 odom->index[i] = odom->start[i];
#70 odom->index[i] = odom->start[i]; /* reset this position*/
#82     const size_t *start, const size_t *edges,
#99      stat = ncp->dispatch->get_vara(ncid,varid,start,shape,value,memtype);
#101      stat =  ncp->dispatch->get_vara(ncid,varid,start,edges,value,memtype);
#125NCDEFAULT_get_vars(int ncid, int varid, const size_t * start,
#134   return ncp->dispatch->get_varm(ncid,varid,start,edges,stride,NULL,value0,memtype);
#198      return NC_get_vara(ncidvaridstartedge1valuememtype);
#205 mystart[i] = (start == NULL ? 0 : start[i]);
#208         myedges[i] = numrecs - start[i];
#272NCDEFAULT_get_varm(int ncid, int varid, const size_t *start,
#320      return NC_get_vara(ncidvaridstartedge1valuememtype);
#363      return NC_get_vara(ncidvaridstartedgesvaluememtype);
#383  mystart[idim] = start != NULL
#384     ? start[idim]
#498     mystart[idim] = start[idim];
#514NC_get_vars(int ncid, int varid, const size_t *start,
#525   return ncp->dispatch->get_vars(ncid,varid,start,edges,stride,value,memtype);
#533NC_get_varm(int ncid, int varid, const size_t *start,
#544   return ncp->dispatch->get_varm(ncid,varid,start,edges,stride,map,value,memtype);
dvarput.c#15    size_t         start[NC_MAX_VAR_DIMS];
#24     const size_t* start, const size_t* edges, const ptrdiff_tstride)
#31 odom->start[i] = (start != NULL ? start[i] : 0);
#34 odom->stop[i] = odom->start[i] + (odom->edges[i]*(size_t)odom->stride[i]);
#35 odom->index[i] = odom->start[i];
#54 odom->index[i] = odom->start[i]; /* reset this position*/
#64NC_put_vara(int ncid, int varid, const size_t *start,
#77      return ncp->dispatch->put_vara(ncidvaridstartshapevaluememtype);
#79      return ncp->dispatch->put_vara(ncidvaridstartedgesvaluememtype);
#111NCDEFAULT_put_vars(int ncid, int varid, const size_t * start,
#120   return ncp->dispatch->put_varm(ncid,varid,start,edges,stride,NULL,value0,memtype);
#191      return NC_put_vara(ncidvaridstartedge1value0memtype);
#198 mystart[i] = (start == NULL ? 0 : start[i]);
#202         myedges[i] = numrecs - start[i];
#205         myedges[i] = varshape[i] - start[i];
#274   const size_t * start,
#328      return NC_put_vara(ncidvaridstartedge1valuememtype);
#369  return NC_put_vara(ncidvaridstartedgesvaluememtype);
#391  mystart[idim] = start != NULL
#392     ? start[idim]
#479     mystart[idim] = start[idim];
#495NC_put_vars(int ncid, int varid, const size_t *start,
#506   return ncp->dispatch->put_vars(ncid,varid,start,edges,stride,value,memtype);
#513NC_put_varm(int ncid, int varid, const size_t *start,
#524   return ncp->dispatch->put_varm(ncid,varid,start,edges,stride,map,value,memtype);
genbin.c#375             int rank, size_t* start, size_t* count)
#378 return genbin_writeattr(generator,sym,memory,rank,start,count);
#380 return genbin_writevar(generator,sym,memory,rank,start,count);
#388                int rank, size_t* start,
#400    { int i; for(i=0;i<rank;i++) count[i] = indices[i] - start[i];}
#408 fprintf(stderr,"%s%lu",(i>0?", ":""),(unsigned long)start[i]);
#422        stat = nc_put_vara(vsym->container->ncidvsym->ncidstartcountdata);
#431           int rank, size_t* start, size_t* count)
genc.c#31                       int rank, size_t* start, size_t* count);
#946           int rank, size_t* start, size_t* count)
#949 genc_writeattr(generator,sym,code,rank,start,count);
#951 genc_writevar(generator,sym,code,rank,start,count);
#958           int rank, size_t* start, size_t* count)
#1039     bbprintf(stmt,"%s%lu",(i>0?", ":""),start[i]);
#1071               int rank, size_t* start, size_t* count)
generate.c#48 ASSERT(odom->index[i] == odom->start[i]+odom->count[i]);
#85    const size_t* start;
#104 start = odometerstartvector(odom);
#155            writer(generator,vsym,code,odom->rank,odom->start,odom->count);
#180                writer(generator,vsym,code,rank,odom->start,odom->count);
#189            size_t nelems=nc_next_iter(&iter,odom->start,odom->count);
#196            writer(generator,vsym,code,odom->rank,odom->start,odom->count);
genf77.c#706             int rank, size_t* start, size_t* count)
#709 genf77_writeattr(generator,sym,code,rank,start,count);
#711 genf77_writevar(generator,sym,code,rank,start,count);
#719           int rank, size_t* start, size_t* count)
#817     start[reverse]+1); /* +1 for FORTRAN */
#853        int rank, size_t* start, size_t* count)
genj.c#33                       int rank, size_t* start, size_t* count);
#417           int rank, size_t* start, size_t* count)
#420 genj_writeattr(generator,sym,code,rank,start,count);
#422 genj_writevar(generator,sym,code,rank,start,count);
#429              int rank, size_t* start, size_t* count)
#503     bbprintf(stmt,"%s%lu",(i>0?", ":""),start[i]);
#518               int rank, size_t* start, size_t* count)
getvara.c#700        if(odom->start[i] != 0 || odom->stride[i] != 1
#1203     const size_t *start,
#1312 ncstat = nc_get_vars_text(ncid,varid,startedgesstride,
#1316 ncstat = nc_get_vars_schar(ncid,varid,startedgesstride,
#1320 ncstat = nc_get_vars_short(ncid,varidstartedgesstride,
#1324 ncstat = nc_get_vars_int(ncid,varid,startedgesstride,
#1328 ncstat = nc_get_vars_float(ncid,varid,startedgesstride,
#1332 ncstat = nc_get_vars_double(ncid,varid, startedgesstride,
#1339    odom = dapodom_new(ncrank,start,edges,stride,NULL);
#1357    odom = dapodom_new(ncrank,start,edges,stride,NULL);
load.c#504    size_t start[NC_MAX_VAR_DIMS];
#535 start[0] = 0;
#545 start[idim] = 0;
#551 stat = nc_put_vara_schar(ncidvarnumstartcount,
#555 stat = nc_put_vara_text(ncidvarnumstartcountcharvalp);
#558 stat = nc_put_vara_short(ncidvarnumstartcountshortvalp);
#561 stat = nc_put_vara_int(ncidvarnumstartcountintvalp);
#564 stat = nc_put_vara_float(ncidvarnumstartcountfloatvalp);
#567 stat = nc_put_vara_double(ncidvarnumstartcountdoublevalp);
nc3dispatch.h#172         const size_t *start, const size_t *count,
#177      const size_t *start, const size_t *count,
nc4dispatch.h#146         const size_t *start, const size_t *count,
#151      const size_t *start, const size_t *count,
nc4hdf.c#497             hsize_t *starthsize_t *count)
#508      LOG((4, "start[%d]=%Ld  count[%d]=%Ld", d2start[d2], d2count[d2]));
#555  hsize_t start[NC_MAX_VAR_DIMS], count[NC_MAX_VAR_DIMS];
#586      start[i] = startp[i];
#617  log_dim_info(varfdimsfmaxdimsstartcount);
#628          if (start[d2] > (hssize_t)fdims[d2] ||
#629              (start[d2] == (hssize_t)fdims[d2] && count[d2] > 0))
#631          if (start[d2] + count[d2] > fdims[d2])
#650      if (H5Sselect_hyperslab(file_spaceidH5S_SELECT_SETstartNULL,
#735              if (start[d2] + count[d2] > fdims[d2])
#737                  xtend_size[d2] = (long long unsigned)(start[d2] + count[d2]);
#743              if (start[d2] + count[d2] > dim->len)
#745                  dim->len = start[d2] + count[d2];
#797                                  startNULLcountNULL) < 0)
#879  hsize_t start[NC_MAX_VAR_DIMS];
#911      start[i] = startp[i];
#942  log_dim_info(varfdimsfmaxdimsstartcount);
#960        if (start[d2] > (hssize_t)ulen ||
#961            (start[d2] == (hssize_t)ulen && count[d2] > 0))
#963        if (start[d2] + count[d2] > ulen)
#971        if (start[d2] >= (hssize_t)fdims[d2])
#973        else if (start[d2] + count[d2] > fdims[d2])
#974          fill_value_size[d2] = count[d2] - (fdims[d2] - start[d2]);
#984        if (start[d2] > (hssize_t)fdims[d2] ||
#985            (start[d2] == (hssize_t)fdims[d2] && count[d2] > 0))
#987        if (start[d2] + count[d2] > fdims[d2])
#1024                                  startNULLcountNULL) < 0)
#1196          real_data_size *= (count[d2] - start[d2]);
nc_iter.c#89      size_t *start,  /* returned start vector for next vara call */
#95            start[i] = 0;
#98        start[iter->right_dim] = 0;
#101            start[i] = 0;
#107                              iter->incstart);
nc_iter.h#46nc_next_iter(nciter_t *iterp, size_t *start, size_t *count);
nccopy.c#965    size_t *start;
#1038    start = (size_t *) emalloc((iterp->rank + 1) * sizeof(size_t));
#1043    while((ntoget = nc_next_iter(iterpstartcount)) > 0) {
#1044 NC_CHECK(nc_get_vara(igrpvaridstartcountbuf));
#1045 NC_CHECK(nc_put_vara(ogrpovaridstartcountbuf));
#1065    free(start);
#1242   size_t *start,   /* start indices for record data */
#1247    NC_CHECK(nc_get_vara(ncidvaridstartcountbuf));
#1248    NC_CHECK(nc_put_vara(ogrpovaridstartcountbuf));
#1261    size_t **start;
#1267    start = (size_t **) emalloc(nrec_vars * sizeof(size_t*));
#1282 start[ivar] = (size_t *) emalloc(ndims * sizeof(size_t));
#1292     start[ivar][ii] = 0;
#1295 start[ivar][0] = 0;
#1310     start[ivar][0] = irec;
#1312        start[ivar], count[ivar], buf[ivar]));
#1316 if(start[ivar])
#1317     free(start[ivar]);
#1321    if(start)
#1322 free(start);
ncd2dispatch.c#76     const size_t *start, const size_t *edges0,
#81     const size_t *start, const size_t *edges,
#86     const size_t *start, const size_t *edges, const ptrdiff_tstride,
#90     const size_t *start, const size_t *edges, const ptrdiff_tstride,
#258     const size_t *start, const size_t *edges,
#267     const size_t *start, const size_t *edges,
#271    int stat = nc3d_getvarx(ncidvaridstartedgesnc_ptrdiffvector1value,memtype);
#277     const size_t *start, const size_t *edges, const ptrdiff_tstride,
#285     const size_t *start, const size_t *edges, const ptrdiff_tstride,
#288    int stat = nc3d_getvarx(ncidvaridstartedgesstridevaluememtype);
nciter.c#241      size_t *start,  /* returned start vector for next vara call */
#251 start[i] = 0;
#254     start[iter->right_dim] = 0;
#257 start[i] = 0;
#262 start[i] = 0;
#273   iter->incstart);
#288     iter->chunksizesstart);
#291 int leftover = iter->dimsizes[i] - start[i];
nciter.h#50nc_next_iter(nciter_t *iterp, size_t *start, size_t *count);
oc.c#1370                 size_t* start, size_t* edges,
#1380    if(start == NULL && edges == NULL) /* Assume it is a scalar read */
#1381        return OCTHROW(oc_data_readn(link,datanode,start,0,memsize,memory));
#1391    return OCTHROW(oc_data_readn(link,datanode,start,count,memsize,memory));
#1454                 size_t* start, size_t N,
#1479    } else if(start == NULL) {
#1482 startpoint = ocarrayoffset(rank,pattern->array.sizes,start);
#1525                 size_t* start, size_t* edges,
#1537    return OCTHROW(oc_data_read(link,data,start,edges,memsize,memory));
#1608                 size_t* start, size_t N,
#1620    return OCTHROW(oc_data_readn(link,data,start,N,memsize,memory));
ocdata.c#235ocdata_read(OCstatestateOCdatadata, size_t start, size_t count,
#274        if(start >= data->ninstances
#275           || (start+count) > data->ninstances)
#278        stat = ocread(data,xdrs,(char*)memory,memsize,start,count);
#290ocread(OCdatadataXXDRxdrs, char* memory, size_t memsize, size_t start, size_t count)
#302    OCASSERT((start+count) <= data->ninstances);
#310    xdrstart = start*data->xdrsize; /* offset from the start of the data */
#403     off_t offset = data->strings[start+i];
odom.c#29 odom->start[i] = (startp == NULL ? 0
#33 odom->index[i] = odom->start[i];
#35 ASSERT(odom->start[i] + odom->count[i] <= odom->declsize[i]);
#41newsubodometer(OdometeroriginDimsetdimset, int start, int stop)
#46    ASSERT(stop > start);
#50    odom->offset = start;
#51    odom->rank = (stop - start);
#75 (unsigned long)odom->origin->start[ioffset],
#87    size_t index,start,count;
#91    start = odom->origin->start[offset];
#93    if(index < start + count) return 1;
#95    odom->origin->index[offset] = odom->origin->start[offset];
#109           < (odom->origin->start[ioffset]
#113 odom->origin->index[ioffset] = odom->origin->start[ioffset];
#150    return odom->start;
odom.h#13    size_t    start[NC_MAX_VAR_DIMS];
#27         int start, int stop);
parallel_vara.c#88    size_t global_nyglobal_nxstart[2], count[2];
#156    start[0] = 0;
#157    start[1] = NX * rank;
#161    err = nc_put_vara_int(ncidvaridstartcount, &buf[0][0]); ERR
#182    err = nc_get_vara_int(ncidvaridstartcount, &buf[0][0]); ERR
pres_temp_4D_rd.c#70   size_t start[NDIMS], count[NDIMS];
#125   start[1] = 0;
#126   start[2] = 0;
#127   start[3] = 0;
#132      start[0] = rec;
#133      if ((retval = nc_get_vara_float(ncidpres_varidstart,
#136      if ((retval = nc_get_vara_float(ncidtemp_varidstart,
pres_temp_4D_wr.c#67   size_t start[NDIMS], count[NDIMS];
#180   start[1] = 0;
#181   start[2] = 0;
#182   start[3] = 0;
#190      start[0] = rec;
#191      if ((retval = nc_put_vara_float(ncidpres_varidstartcount,
#194      if ((retval = nc_put_vara_float(ncidtemp_varidstartcount,
putget.c#31readNCv(const NC3_INFOncp, const NC_varvarp, const size_t* start,
#34writeNCv(NC3_INFOncp, const NC_varvarp, const size_t* start,
#789  const size_t *start, const size_t *edges)
#791 const size_t *const end = start + varp->ndims;
#799 start++;
#804 for(; start < endstart++, edges++, shp++)
#808 (unsigned long) *start + (unsigned long) *edges > *shp)
#862  const size_t *start, size_t nelems, const char *value)
#864 off_t offset = NC_varoffset(ncpvarpstart);
#908  const size_t *start, size_t nelems, const schar *value)
#910 off_t offset = NC_varoffset(ncpvarpstart);
#953  const size_t *start, size_t nelems, const uchar *value)
#955 off_t offset = NC_varoffset(ncpvarpstart);
#998  const size_t *start, size_t nelems, const short *value)
#1000 off_t offset = NC_varoffset(ncpvarpstart);
#1043  const size_t *start, size_t nelems, const int *value)
#1045 off_t offset = NC_varoffset(ncpvarpstart);
#1088  const size_t *start, size_t nelems, const float *value)
#1090 off_t offset = NC_varoffset(ncpvarpstart);
#1133  const size_t *start, size_t nelems, const double *value)
#1135 off_t offset = NC_varoffset(ncpvarpstart);
#1178  const size_t *start, size_t nelems, const longlong *value)
#1180 off_t offset = NC_varoffset(ncpvarpstart);
#1223  const size_t *start, size_t nelems, const ushort *value)
#1225 off_t offset = NC_varoffset(ncpvarpstart);
#1268  const size_t *start, size_t nelems, const uint *value)
#1270 off_t offset = NC_varoffset(ncpvarpstart);
#1313  const size_t *start, size_t nelems, const ulonglong *value)
#1315 off_t offset = NC_varoffset(ncpvarpstart);
#1359  const size_t *start, size_t nelems, const schar *value)
#1361 off_t offset = NC_varoffset(ncpvarpstart);
#1404  const size_t *start, size_t nelems, const uchar *value)
#1406 off_t offset = NC_varoffset(ncpvarpstart);
#1449  const size_t *start, size_t nelems, const short *value)
#1451 off_t offset = NC_varoffset(ncpvarpstart);
#1494  const size_t *start, size_t nelems, const int *value)
#1496 off_t offset = NC_varoffset(ncpvarpstart);
#1539  const size_t *start, size_t nelems, const float *value)
#1541 off_t offset = NC_varoffset(ncpvarpstart);
#1584  const size_t *start, size_t nelems, const double *value)
#1586 off_t offset = NC_varoffset(ncpvarpstart);
#1629  const size_t *start, size_t nelems, const longlong *value)
#1631 off_t offset = NC_varoffset(ncpvarpstart);
#1674  const size_t *start, size_t nelems, const ushort *value)
#1676 off_t offset = NC_varoffset(ncpvarpstart);
#1719  const size_t *start, size_t nelems, const uint *value)
#1721 off_t offset = NC_varoffset(ncpvarpstart);
#1764  const size_t *start, size_t nelems, const ulonglong *value)
#1766 off_t offset = NC_varoffset(ncpvarpstart);
#1810  const size_t *start, size_t nelems, const schar *value)
#1812 off_t offset = NC_varoffset(ncpvarpstart);
#1855  const size_t *start, size_t nelems, const uchar *value)
#1857 off_t offset = NC_varoffset(ncpvarpstart);
#1900  const size_t *start, size_t nelems, const short *value)
#1902 off_t offset = NC_varoffset(ncpvarpstart);
#1945  const size_t *start, size_t nelems, const int *value)
#1947 off_t offset = NC_varoffset(ncpvarpstart);
#1990  const size_t *start, size_t nelems, const float *value)
#1992 off_t offset = NC_varoffset(ncpvarpstart);
#2035  const size_t *start, size_t nelems, const double *value)
#2037 off_t offset = NC_varoffset(ncpvarpstart);
#2080  const size_t *start, size_t nelems, const longlong *value)
#2082 off_t offset = NC_varoffset(ncpvarpstart);
#2125  const size_t *start, size_t nelems, const ushort *value)
#2127 off_t offset = NC_varoffset(ncpvarpstart);
#2170  const size_t *start, size_t nelems, const uint *value)
#2172 off_t offset = NC_varoffset(ncpvarpstart);
#2215  const size_t *start, size_t nelems, const ulonglong *value)
#2217 off_t offset = NC_varoffset(ncpvarpstart);
#2261  const size_t *start, size_t nelems, const schar *value)
#2263 off_t offset = NC_varoffset(ncpvarpstart);
#2306  const size_t *start, size_t nelems, const uchar *value)
#2308 off_t offset = NC_varoffset(ncpvarpstart);
#2351  const size_t *start, size_t nelems, const short *value)
#2353 off_t offset = NC_varoffset(ncpvarpstart);
#2396  const size_t *start, size_t nelems, const int *value)
#2398 off_t offset = NC_varoffset(ncpvarpstart);
#2441  const size_t *start, size_t nelems, const float *value)
#2443 off_t offset = NC_varoffset(ncpvarpstart);
#2486  const size_t *start, size_t nelems, const double *value)
#2488 off_t offset = NC_varoffset(ncpvarpstart);
#2531  const size_t *start, size_t nelems, const longlong *value)
#2533 off_t offset = NC_varoffset(ncpvarpstart);
#2576  const size_t *start, size_t nelems, const ushort *value)
#2578 off_t offset = NC_varoffset(ncpvarpstart);
#2621  const size_t *start, size_t nelems, const uint *value)
#2623 off_t offset = NC_varoffset(ncpvarpstart);
#2666  const size_t *start, size_t nelems, const ulonglong *value)
#2668 off_t offset = NC_varoffset(ncpvarpstart);
#2712  const size_t *start, size_t nelems, const schar *value)
#2714 off_t offset = NC_varoffset(ncpvarpstart);
#2757  const size_t *start, size_t nelems, const uchar *value)
#2759 off_t offset = NC_varoffset(ncpvarpstart);
#2802  const size_t *start, size_t nelems, const short *value)
#2804 off_t offset = NC_varoffset(ncpvarpstart);
#2847  const size_t *start, size_t nelems, const int *value)
#2849 off_t offset = NC_varoffset(ncpvarpstart);
#2892  const size_t *start, size_t nelems, const float *value)
#2894 off_t offset = NC_varoffset(ncpvarpstart);
#2937  const size_t *start, size_t nelems, const double *value)
#2939 off_t offset = NC_varoffset(ncpvarpstart);
#2982  const size_t *start, size_t nelems, const longlong *value)
#2984 off_t offset = NC_varoffset(ncpvarpstart);
#3027  const size_t *start, size_t nelems, const ushort *value)
#3029 off_t offset = NC_varoffset(ncpvarpstart);
#3072  const size_t *start, size_t nelems, const uint *value)
#3074 off_t offset = NC_varoffset(ncpvarpstart);
#3117  const size_t *start, size_t nelems, const ulonglong *value)
#3119 off_t offset = NC_varoffset(ncpvarpstart);
#3163  const size_t *start, size_t nelems, const schar *value)
#3165 off_t offset = NC_varoffset(ncpvarpstart);
#3208  const size_t *start, size_t nelems, const uchar *value)
#3210 off_t offset = NC_varoffset(ncpvarpstart);
#3253  const size_t *start, size_t nelems, const short *value)
#3255 off_t offset = NC_varoffset(ncpvarpstart);
#3298  const size_t *start, size_t nelems, const int *value)
#3300 off_t offset = NC_varoffset(ncpvarpstart);
#3343  const size_t *start, size_t nelems, const float *value)
#3345 off_t offset = NC_varoffset(ncpvarpstart);
#3388  const size_t *start, size_t nelems, const double *value)
#3390 off_t offset = NC_varoffset(ncpvarpstart);
#3433  const size_t *start, size_t nelems, const longlong *value)
#3435 off_t offset = NC_varoffset(ncpvarpstart);
#3478  const size_t *start, size_t nelems, const ushort *value)
#3480 off_t offset = NC_varoffset(ncpvarpstart);
#3523  const size_t *start, size_t nelems, const uint *value)
#3525 off_t offset = NC_varoffset(ncpvarpstart);
#3568  const size_t *start, size_t nelems, const ulonglong *value)
#3570 off_t offset = NC_varoffset(ncpvarpstart);
#3614  const size_t *start, size_t nelems, const schar *value)
#3616 off_t offset = NC_varoffset(ncpvarpstart);
#3659  const size_t *start, size_t nelems, const uchar *value)
#3661 off_t offset = NC_varoffset(ncpvarpstart);
#3704  const size_t *start, size_t nelems, const short *value)
#3706 off_t offset = NC_varoffset(ncpvarpstart);
#3749  const size_t *start, size_t nelems, const int *value)
#3751 off_t offset = NC_varoffset(ncpvarpstart);
#3794  const size_t *start, size_t nelems, const float *value)
#3796 off_t offset = NC_varoffset(ncpvarpstart);
#3839  const size_t *start, size_t nelems, const double *value)
#3841 off_t offset = NC_varoffset(ncpvarpstart);
#3884  const size_t *start, size_t nelems, const longlong *value)
#3886 off_t offset = NC_varoffset(ncpvarpstart);
#3929  const size_t *start, size_t nelems, const ushort *value)
#3931 off_t offset = NC_varoffset(ncpvarpstart);
#3974  const size_t *start, size_t nelems, const uint *value)
#3976 off_t offset = NC_varoffset(ncpvarpstart);
#4019  const size_t *start, size_t nelems, const ulonglong *value)
#4021 off_t offset = NC_varoffset(ncpvarpstart);
#4065  const size_t *start, size_t nelems, const schar *value)
#4067 off_t offset = NC_varoffset(ncpvarpstart);
#4110  const size_t *start, size_t nelems, const uchar *value)
#4112 off_t offset = NC_varoffset(ncpvarpstart);
#4155  const size_t *start, size_t nelems, const short *value)
#4157 off_t offset = NC_varoffset(ncpvarpstart);
#4200  const size_t *start, size_t nelems, const int *value)
#4202 off_t offset = NC_varoffset(ncpvarpstart);
#4245  const size_t *start, size_t nelems, const float *value)
#4247 off_t offset = NC_varoffset(ncpvarpstart);
#4290  const size_t *start, size_t nelems, const double *value)
#4292 off_t offset = NC_varoffset(ncpvarpstart);
#4335  const size_t *start, size_t nelems, const longlong *value)
#4337 off_t offset = NC_varoffset(ncpvarpstart);
#4380  const size_t *start, size_t nelems, const ushort *value)
#4382 off_t offset = NC_varoffset(ncpvarpstart);
#4425  const size_t *start, size_t nelems, const uint *value)
#4427 off_t offset = NC_varoffset(ncpvarpstart);
#4470  const size_t *start, size_t nelems, const ulonglong *value)
#4472 off_t offset = NC_varoffset(ncpvarpstart);
#4516  const size_t *start, size_t nelems, const schar *value)
#4518 off_t offset = NC_varoffset(ncpvarpstart);
#4561  const size_t *start, size_t nelems, const uchar *value)
#4563 off_t offset = NC_varoffset(ncpvarpstart);
#4606  const size_t *start, size_t nelems, const short *value)
#4608 off_t offset = NC_varoffset(ncpvarpstart);
#4651  const size_t *start, size_t nelems, const int *value)
#4653 off_t offset = NC_varoffset(ncpvarpstart);
#4696  const size_t *start, size_t nelems, const float *value)
#4698 off_t offset = NC_varoffset(ncpvarpstart);
#4741  const size_t *start, size_t nelems, const double *value)
#4743 off_t offset = NC_varoffset(ncpvarpstart);
#4786  const size_t *start, size_t nelems, const longlong *value)
#4788 off_t offset = NC_varoffset(ncpvarpstart);
#4831  const size_t *start, size_t nelems, const ushort *value)
#4833 off_t offset = NC_varoffset(ncpvarpstart);
#4876  const size_t *start, size_t nelems, const uint *value)
#4878 off_t offset = NC_varoffset(ncpvarpstart);
#4921  const size_t *start, size_t nelems, const ulonglong *value)
#4923 off_t offset = NC_varoffset(ncpvarpstart);
#4967  const size_t *start, size_t nelems, const schar *value)
#4969 off_t offset = NC_varoffset(ncpvarpstart);
#5012  const size_t *start, size_t nelems, const uchar *value)
#5014 off_t offset = NC_varoffset(ncpvarpstart);
#5057  const size_t *start, size_t nelems, const short *value)
#5059 off_t offset = NC_varoffset(ncpvarpstart);
#5102  const size_t *start, size_t nelems, const int *value)
#5104 off_t offset = NC_varoffset(ncpvarpstart);
#5147  const size_t *start, size_t nelems, const float *value)
#5149 off_t offset = NC_varoffset(ncpvarpstart);
#5192  const size_t *start, size_t nelems, const double *value)
#5194 off_t offset = NC_varoffset(ncpvarpstart);
#5237  const size_t *start, size_t nelems, const longlong *value)
#5239 off_t offset = NC_varoffset(ncpvarpstart);
#5282  const size_t *start, size_t nelems, const ushort *value)
#5284 off_t offset = NC_varoffset(ncpvarpstart);
#5327  const size_t *start, size_t nelems, const uint *value)
#5329 off_t offset = NC_varoffset(ncpvarpstart);
#5372  const size_t *start, size_t nelems, const ulonglong *value)
#5374 off_t offset = NC_varoffset(ncpvarpstart);
#5419  const size_t *start, size_t nelems, char *value)
#5421 off_t offset = NC_varoffset(ncpvarpstart);
#5460  const size_t *start, size_t nelemsschar *value)
#5462 off_t offset = NC_varoffset(ncpvarpstart);
#5500  const size_t *start, size_t nelems, short *value)
#5502 off_t offset = NC_varoffset(ncpvarpstart);
#5540  const size_t *start, size_t nelems, int *value)
#5542 off_t offset = NC_varoffset(ncpvarpstart);
#5580  const size_t *start, size_t nelems, float *value)
#5582 off_t offset = NC_varoffset(ncpvarpstart);
#5620  const size_t *start, size_t nelems, double *value)
#5622 off_t offset = NC_varoffset(ncpvarpstart);
#5660  const size_t *start, size_t nelemslonglong *value)
#5662 off_t offset = NC_varoffset(ncpvarpstart);
#5700  const size_t *start, size_t nelemsuint *value)
#5702 off_t offset = NC_varoffset(ncpvarpstart);
#5740  const size_t *start, size_t nelemsulonglong *value)
#5742 off_t offset = NC_varoffset(ncpvarpstart);
#5780  const size_t *start, size_t nelemsuchar *value)
#5782 off_t offset = NC_varoffset(ncpvarpstart);
#5820  const size_t *start, size_t nelemsushort *value)
#5822 off_t offset = NC_varoffset(ncpvarpstart);
#5861  const size_t *start, size_t nelemsschar *value)
#5863 off_t offset = NC_varoffset(ncpvarpstart);
#5901  const size_t *start, size_t nelemsuchar *value)
#5903 off_t offset = NC_varoffset(ncpvarpstart);
#5941  const size_t *start, size_t nelems, short *value)
#5943 off_t offset = NC_varoffset(ncpvarpstart);
#5981  const size_t *start, size_t nelems, int *value)
#5983 off_t offset = NC_varoffset(ncpvarpstart);
#6021  const size_t *start, size_t nelems, float *value)
#6023 off_t offset = NC_varoffset(ncpvarpstart);
#6061  const size_t *start, size_t nelems, double *value)
#6063 off_t offset = NC_varoffset(ncpvarpstart);
#6101  const size_t *start, size_t nelemslonglong *value)
#6103 off_t offset = NC_varoffset(ncpvarpstart);
#6141  const size_t *start, size_t nelemsuint *value)
#6143 off_t offset = NC_varoffset(ncpvarpstart);
#6181  const size_t *start, size_t nelemsulonglong *value)
#6183 off_t offset = NC_varoffset(ncpvarpstart);
#6221  const size_t *start, size_t nelemsushort *value)
#6223 off_t offset = NC_varoffset(ncpvarpstart);
#6262  const size_t *start, size_t nelemsschar *value)
#6264 off_t offset = NC_varoffset(ncpvarpstart);
#6302  const size_t *start, size_t nelemsuchar *value)
#6304 off_t offset = NC_varoffset(ncpvarpstart);
#6342  const size_t *start, size_t nelems, short *value)
#6344 off_t offset = NC_varoffset(ncpvarpstart);
#6382  const size_t *start, size_t nelems, int *value)
#6384 off_t offset = NC_varoffset(ncpvarpstart);
#6422  const size_t *start, size_t nelems, float *value)
#6424 off_t offset = NC_varoffset(ncpvarpstart);
#6462  const size_t *start, size_t nelems, double *value)
#6464 off_t offset = NC_varoffset(ncpvarpstart);
#6502  const size_t *start, size_t nelemslonglong *value)
#6504 off_t offset = NC_varoffset(ncpvarpstart);
#6542  const size_t *start, size_t nelemsuint *value)
#6544 off_t offset = NC_varoffset(ncpvarpstart);
#6582  const size_t *start, size_t nelemsulonglong *value)
#6584 off_t offset = NC_varoffset(ncpvarpstart);
#6622  const size_t *start, size_t nelemsushort *value)
#6624 off_t offset = NC_varoffset(ncpvarpstart);
#6663  const size_t *start, size_t nelemsschar *value)
#6665 off_t offset = NC_varoffset(ncpvarpstart);
#6703  const size_t *start, size_t nelemsuchar *value)
#6705 off_t offset = NC_varoffset(ncpvarpstart);
#6743  const size_t *start, size_t nelems, short *value)
#6745 off_t offset = NC_varoffset(ncpvarpstart);
#6783  const size_t *start, size_t nelems, int *value)
#6785 off_t offset = NC_varoffset(ncpvarpstart);
#6823  const size_t *start, size_t nelems, float *value)
#6825 off_t offset = NC_varoffset(ncpvarpstart);
#6863  const size_t *start, size_t nelems, double *value)
#6865 off_t offset = NC_varoffset(ncpvarpstart);
#6903  const size_t *start, size_t nelemslonglong *value)
#6905 off_t offset = NC_varoffset(ncpvarpstart);
#6943  const size_t *start, size_t nelemsuint *value)
#6945 off_t offset = NC_varoffset(ncpvarpstart);
#6983  const size_t *start, size_t nelemsulonglong *value)
#6985 off_t offset = NC_varoffset(ncpvarpstart);
#7023  const size_t *start, size_t nelemsushort *value)
#7025 off_t offset = NC_varoffset(ncpvarpstart);
#7064  const size_t *start, size_t nelemsschar *value)
#7066 off_t offset = NC_varoffset(ncpvarpstart);
#7104  const size_t *start, size_t nelemsuchar *value)
#7106 off_t offset = NC_varoffset(ncpvarpstart);
#7144  const size_t *start, size_t nelems, short *value)
#7146 off_t offset = NC_varoffset(ncpvarpstart);
#7184  const size_t *start, size_t nelems, int *value)
#7186 off_t offset = NC_varoffset(ncpvarpstart);
#7224  const size_t *start, size_t nelems, float *value)
#7226 off_t offset = NC_varoffset(ncpvarpstart);
#7264  const size_t *start, size_t nelems, double *value)
#7266 off_t offset = NC_varoffset(ncpvarpstart);
#7304  const size_t *start, size_t nelemslonglong *value)
#7306 off_t offset = NC_varoffset(ncpvarpstart);
#7344  const size_t *start, size_t nelemsuint *value)
#7346 off_t offset = NC_varoffset(ncpvarpstart);
#7384  const size_t *start, size_t nelemsulonglong *value)
#7386 off_t offset = NC_varoffset(ncpvarpstart);
#7424  const size_t *start, size_t nelemsushort *value)
#7426 off_t offset = NC_varoffset(ncpvarpstart);
#7465  const size_t *start, size_t nelemsschar *value)
#7467 off_t offset = NC_varoffset(ncpvarpstart);
#7505  const size_t *start, size_t nelemsuchar *value)
#7507 off_t offset = NC_varoffset(ncpvarpstart);
#7545  const size_t *start, size_t nelems, short *value)
#7547 off_t offset = NC_varoffset(ncpvarpstart);
#7585  const size_t *start, size_t nelems, int *value)
#7587 off_t offset = NC_varoffset(ncpvarpstart);
#7625  const size_t *start, size_t nelems, float *value)
#7627 off_t offset = NC_varoffset(ncpvarpstart);
#7665  const size_t *start, size_t nelems, double *value)
#7667 off_t offset = NC_varoffset(ncpvarpstart);
#7705  const size_t *start, size_t nelemslonglong *value)
#7707 off_t offset = NC_varoffset(ncpvarpstart);
#7745  const size_t *start, size_t nelemsuint *value)
#7747 off_t offset = NC_varoffset(ncpvarpstart);
#7785  const size_t *start, size_t nelemsulonglong *value)
#7787 off_t offset = NC_varoffset(ncpvarpstart);
#7825  const size_t *start, size_t nelemsushort *value)
#7827 off_t offset = NC_varoffset(ncpvarpstart);
#7866  const size_t *start, size_t nelemsschar *value)
#7868 off_t offset = NC_varoffset(ncpvarpstart);
#7906  const size_t *start, size_t nelemsuchar *value)
#7908 off_t offset = NC_varoffset(ncpvarpstart);
#7946  const size_t *start, size_t nelems, short *value)
#7948 off_t offset = NC_varoffset(ncpvarpstart);
#7986  const size_t *start, size_t nelems, int *value)
#7988 off_t offset = NC_varoffset(ncpvarpstart);
#8026  const size_t *start, size_t nelems, float *value)
#8028 off_t offset = NC_varoffset(ncpvarpstart);
#8066  const size_t *start, size_t nelems, double *value)
#8068 off_t offset = NC_varoffset(ncpvarpstart);
#8106  const size_t *start, size_t nelemslonglong *value)
#8108 off_t offset = NC_varoffset(ncpvarpstart);
#8146  const size_t *start, size_t nelemsuint *value)
#8148 off_t offset = NC_varoffset(ncpvarpstart);
#8186  const size_t *start, size_t nelemsulonglong *value)
#8188 off_t offset = NC_varoffset(ncpvarpstart);
#8226  const size_t *start, size_t nelemsushort *value)
#8228 off_t offset = NC_varoffset(ncpvarpstart);
#8267  const size_t *start, size_t nelemsschar *value)
#8269 off_t offset = NC_varoffset(ncpvarpstart);
#8307  const size_t *start, size_t nelemsuchar *value)
#8309 off_t offset = NC_varoffset(ncpvarpstart);
#8347  const size_t *start, size_t nelems, short *value)
#8349 off_t offset = NC_varoffset(ncpvarpstart);
#8387  const size_t *start, size_t nelems, int *value)
#8389 off_t offset = NC_varoffset(ncpvarpstart);
#8427  const size_t *start, size_t nelems, float *value)
#8429 off_t offset = NC_varoffset(ncpvarpstart);
#8467  const size_t *start, size_t nelems, double *value)
#8469 off_t offset = NC_varoffset(ncpvarpstart);
#8507  const size_t *start, size_t nelemslonglong *value)
#8509 off_t offset = NC_varoffset(ncpvarpstart);
#8547  const size_t *start, size_t nelemsuint *value)
#8549 off_t offset = NC_varoffset(ncpvarpstart);
#8587  const size_t *start, size_t nelemsulonglong *value)
#8589 off_t offset = NC_varoffset(ncpvarpstart);
#8627  const size_t *start, size_t nelemsushort *value)
#8629 off_t offset = NC_varoffset(ncpvarpstart);
#8668  const size_t *start, size_t nelemsschar *value)
#8670 off_t offset = NC_varoffset(ncpvarpstart);
#8708  const size_t *start, size_t nelemsuchar *value)
#8710 off_t offset = NC_varoffset(ncpvarpstart);
#8748  const size_t *start, size_t nelems, short *value)
#8750 off_t offset = NC_varoffset(ncpvarpstart);
#8788  const size_t *start, size_t nelems, int *value)
#8790 off_t offset = NC_varoffset(ncpvarpstart);
#8828  const size_t *start, size_t nelems, float *value)
#8830 off_t offset = NC_varoffset(ncpvarpstart);
#8868  const size_t *start, size_t nelems, double *value)
#8870 off_t offset = NC_varoffset(ncpvarpstart);
#8908  const size_t *start, size_t nelemslonglong *value)
#8910 off_t offset = NC_varoffset(ncpvarpstart);
#8948  const size_t *start, size_t nelemsuint *value)
#8950 off_t offset = NC_varoffset(ncpvarpstart);
#8988  const size_t *start, size_t nelemsulonglong *value)
#8990 off_t offset = NC_varoffset(ncpvarpstart);
#9028  const size_t *start, size_t nelemsushort *value)
#9030 off_t offset = NC_varoffset(ncpvarpstart);
#9069  const size_t *start, size_t nelemsschar *value)
#9071 off_t offset = NC_varoffset(ncpvarpstart);
#9109  const size_t *start, size_t nelemsuchar *value)
#9111 off_t offset = NC_varoffset(ncpvarpstart);
#9149  const size_t *start, size_t nelems, short *value)
#9151 off_t offset = NC_varoffset(ncpvarpstart);
#9189  const size_t *start, size_t nelems, int *value)
#9191 off_t offset = NC_varoffset(ncpvarpstart);
#9229  const size_t *start, size_t nelems, float *value)
#9231 off_t offset = NC_varoffset(ncpvarpstart);
#9269  const size_t *start, size_t nelems, double *value)
#9271 off_t offset = NC_varoffset(ncpvarpstart);
#9309  const size_t *start, size_t nelemslonglong *value)
#9311 off_t offset = NC_varoffset(ncpvarpstart);
#9349  const size_t *start, size_t nelemsuint *value)
#9351 off_t offset = NC_varoffset(ncpvarpstart);
#9389  const size_t *start, size_t nelemsulonglong *value)
#9391 off_t offset = NC_varoffset(ncpvarpstart);
#9429  const size_t *start, size_t nelemsushort *value)
#9431 off_t offset = NC_varoffset(ncpvarpstart);
#9471  const size_t *start, size_t nelemsuchar *value)
#9473 off_t offset = NC_varoffset(ncpvarpstart);
#9631odo1(const size_t *const start, const size_t *const upper,
#9645 *cdp = start[cdp - coord];
#9646 odo1(startuppercoordupp -1, cdp -1);
#9659readNCv(const NC3_INFOncp, const NC_varvarp, const size_t* start,
#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);
#9991writeNCv(NC3_INFOncp, const NC_varvarp, const size_t* start,
#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);
#10313     const size_t *start, const size_t *edges0,
#10360    status = NCcoordck(nc3varpstart);
#10364    status = NCedgeck(nc3varpstartedges);
#10373        return( readNCv(nc3varpstart, 1, (void*)valuememtype) );
#10378        if(*start + *edges > NC_get_numrecs(nc3))
#10383            return( readNCv(nc3varpstart, *edges, (void*)valuememtype) );
#10395        return( readNCv(nc3varpstartiocount, (void*)valuememtype) );
#10406    (void) memcpy(coordstartvarp->ndims * sizeof(size_t));
#10409    set_upper(upperstartedges, &upper[varp->ndims]);
#10428        odo1(startuppercoord, &upper[index], &coord[index]);
#10440     const size_t *start, const size_t *edges0,
#10494    status = NCcoordck(nc3varpstart);
#10497    status = NCedgeck(nc3varpstartedges);
#10503        return( writeNCv(nc3varpstart, 1, (void*)valuememtype) );
#10508        status = NCvnrecs(nc3, *start + *edges);
#10516            return( writeNCv(nc3varpstart, *edges, (void*)valuememtype) );
#10528        return( writeNCv(nc3varpstartiocount, (void*)valuememtype) );
#10539    (void) memcpy(coordstartvarp->ndims * sizeof(size_t));
#10542    set_upper(upperstartedges, &upper[varp->ndims]);
#10561        odo1(startuppercoord, &upper[index], &coord[index]);
rec.c#262    long start[MAX_NC_DIMS];
#268    start[0] = recnum;
#270 start[iv] = 0;
#276     if (ncvarput(ncidrvids[iv], startedgesdatap[iv]) == -1)
#299    long start[MAX_NC_DIMS];
#305    start[0] = recnum;
#307 start[iv] = 0;
#313     if (ncvarget(ncidrvids[iv], startedgesdatap[iv]) == -1)
test_get.c#2052    size_t start[MAX_RANK];
#2068     start[j] = 0;
#2071        err = nc_get_vara_text(BAD_IDistartedgevalue);
#2074        err = nc_get_vara_text(ncidBAD_VARIDstartedgevalue);
#2078     start[j] = var_shape[i][j];
#2079     err = nc_get_vara_text(ncidistartedgevalue);
#2082     start[j] = 0;
#2084     err = nc_get_vara_text(ncidistartedgevalue);
#2095     err = nc_get_vara_text(BAD_IDistartedgevalue);
#2098     err = nc_get_vara_text(ncidBAD_VARIDstartedgevalue);
#2101     err = nc_get_vara_text(ncidistartedgevalue);
#2124                    start[j] = 0;
#2127                    start[j] = mid[j];
#2138                    index[d] += start[d];
#2150 err = nc_get_vara_text(ncidistartedgevalue);
#2208    size_t start[MAX_RANK];
#2224     start[j] = 0;
#2227        err = nc_get_vara_uchar(BAD_IDistartedgevalue);
#2230        err = nc_get_vara_uchar(ncidBAD_VARIDstartedgevalue);
#2234     start[j] = var_shape[i][j];
#2235     err = nc_get_vara_uchar(ncidistartedgevalue);
#2238     start[j] = 0;
#2240     err = nc_get_vara_uchar(ncidistartedgevalue);
#2251     err = nc_get_vara_uchar(BAD_IDistartedgevalue);
#2254     err = nc_get_vara_uchar(ncidBAD_VARIDstartedgevalue);
#2257     err = nc_get_vara_uchar(ncidistartedgevalue);
#2280                    start[j] = 0;
#2283                    start[j] = mid[j];
#2294                    index[d] += start[d];
#2306 err = nc_get_vara_uchar(ncidistartedgevalue);
#2364    size_t start[MAX_RANK];
#2380     start[j] = 0;
#2383        err = nc_get_vara_schar(BAD_IDistartedgevalue);
#2386        err = nc_get_vara_schar(ncidBAD_VARIDstartedgevalue);
#2390     start[j] = var_shape[i][j];
#2391     err = nc_get_vara_schar(ncidistartedgevalue);
#2394     start[j] = 0;
#2396     err = nc_get_vara_schar(ncidistartedgevalue);
#2407     err = nc_get_vara_schar(BAD_IDistartedgevalue);
#2410     err = nc_get_vara_schar(ncidBAD_VARIDstartedgevalue);
#2413     err = nc_get_vara_schar(ncidistartedgevalue);
#2436                    start[j] = 0;
#2439                    start[j] = mid[j];
#2450                    index[d] += start[d];
#2462 err = nc_get_vara_schar(ncidistartedgevalue);
#2520    size_t start[MAX_RANK];
#2536     start[j] = 0;
#2539        err = nc_get_vara_short(BAD_IDistartedgevalue);
#2542        err = nc_get_vara_short(ncidBAD_VARIDstartedgevalue);
#2546     start[j] = var_shape[i][j];
#2547     err = nc_get_vara_short(ncidistartedgevalue);
#2550     start[j] = 0;
#2552     err = nc_get_vara_short(ncidistartedgevalue);
#2563     err = nc_get_vara_short(BAD_IDistartedgevalue);
#2566     err = nc_get_vara_short(ncidBAD_VARIDstartedgevalue);
#2569     err = nc_get_vara_short(ncidistartedgevalue);
#2592                    start[j] = 0;
#2595                    start[j] = mid[j];
#2606                    index[d] += start[d];
#2618 err = nc_get_vara_short(ncidistartedgevalue);
#2676    size_t start[MAX_RANK];
#2692     start[j] = 0;
#2695        err = nc_get_vara_int(BAD_IDistartedgevalue);
#2698        err = nc_get_vara_int(ncidBAD_VARIDstartedgevalue);
#2702     start[j] = var_shape[i][j];
#2703     err = nc_get_vara_int(ncidistartedgevalue);
#2706     start[j] = 0;
#2708     err = nc_get_vara_int(ncidistartedgevalue);
#2719     err = nc_get_vara_int(BAD_IDistartedgevalue);
#2722     err = nc_get_vara_int(ncidBAD_VARIDstartedgevalue);
#2725     err = nc_get_vara_int(ncidistartedgevalue);
#2748                    start[j] = 0;
#2751                    start[j] = mid[j];
#2762                    index[d] += start[d];
#2774 err = nc_get_vara_int(ncidistartedgevalue);
#2832    size_t start[MAX_RANK];
#2848     start[j] = 0;
#2851        err = nc_get_vara_long(BAD_IDistartedgevalue);
#2854        err = nc_get_vara_long(ncidBAD_VARIDstartedgevalue);
#2858     start[j] = var_shape[i][j];
#2859     err = nc_get_vara_long(ncidistartedgevalue);
#2862     start[j] = 0;
#2864     err = nc_get_vara_long(ncidistartedgevalue);
#2875     err = nc_get_vara_long(BAD_IDistartedgevalue);
#2878     err = nc_get_vara_long(ncidBAD_VARIDstartedgevalue);
#2881     err = nc_get_vara_long(ncidistartedgevalue);
#2904                    start[j] = 0;
#2907                    start[j] = mid[j];
#2918                    index[d] += start[d];
#2930 err = nc_get_vara_long(ncidistartedgevalue);
#2988    size_t start[MAX_RANK];
#3004     start[j] = 0;
#3007        err = nc_get_vara_float(BAD_IDistartedgevalue);
#3010        err = nc_get_vara_float(ncidBAD_VARIDstartedgevalue);
#3014     start[j] = var_shape[i][j];
#3015     err = nc_get_vara_float(ncidistartedgevalue);
#3018     start[j] = 0;
#3020     err = nc_get_vara_float(ncidistartedgevalue);
#3031     err = nc_get_vara_float(BAD_IDistartedgevalue);
#3034     err = nc_get_vara_float(ncidBAD_VARIDstartedgevalue);
#3037     err = nc_get_vara_float(ncidistartedgevalue);
#3060                    start[j] = 0;
#3063                    start[j] = mid[j];
#3074                    index[d] += start[d];
#3086 err = nc_get_vara_float(ncidistartedgevalue);
#3144    size_t start[MAX_RANK];
#3160     start[j] = 0;
#3163        err = nc_get_vara_double(BAD_IDistartedgevalue);
#3166        err = nc_get_vara_double(ncidBAD_VARIDstartedgevalue);
#3170     start[j] = var_shape[i][j];
#3171     err = nc_get_vara_double(ncidistartedgevalue);
#3174     start[j] = 0;
#3176     err = nc_get_vara_double(ncidistartedgevalue);
#3187     err = nc_get_vara_double(BAD_IDistartedgevalue);
#3190     err = nc_get_vara_double(ncidBAD_VARIDstartedgevalue);
#3193     err = nc_get_vara_double(ncidistartedgevalue);
#3216                    start[j] = 0;
#3219                    start[j] = mid[j];
#3230                    index[d] += start[d];
#3242 err = nc_get_vara_double(ncidistartedgevalue);
#3300    size_t start[MAX_RANK];
#3316     start[j] = 0;
#3319        err = nc_get_vara_ushort(BAD_IDistartedgevalue);
#3322        err = nc_get_vara_ushort(ncidBAD_VARIDstartedgevalue);
#3326     start[j] = var_shape[i][j];
#3327     err = nc_get_vara_ushort(ncidistartedgevalue);
#3330     start[j] = 0;
#3332     err = nc_get_vara_ushort(ncidistartedgevalue);
#3343     err = nc_get_vara_ushort(BAD_IDistartedgevalue);
#3346     err = nc_get_vara_ushort(ncidBAD_VARIDstartedgevalue);
#3349     err = nc_get_vara_ushort(ncidistartedgevalue);
#3372                    start[j] = 0;
#3375                    start[j] = mid[j];
#3386                    index[d] += start[d];
#3398 err = nc_get_vara_ushort(ncidistartedgevalue);
#3456    size_t start[MAX_RANK];
#3472     start[j] = 0;
#3475        err = nc_get_vara_uint(BAD_IDistartedgevalue);
#3478        err = nc_get_vara_uint(ncidBAD_VARIDstartedgevalue);
#3482     start[j] = var_shape[i][j];
#3483     err = nc_get_vara_uint(ncidistartedgevalue);
#3486     start[j] = 0;
#3488     err = nc_get_vara_uint(ncidistartedgevalue);
#3499     err = nc_get_vara_uint(BAD_IDistartedgevalue);
#3502     err = nc_get_vara_uint(ncidBAD_VARIDstartedgevalue);
#3505     err = nc_get_vara_uint(ncidistartedgevalue);
#3528                    start[j] = 0;
#3531                    start[j] = mid[j];
#3542                    index[d] += start[d];
#3554 err = nc_get_vara_uint(ncidistartedgevalue);
#3612    size_t start[MAX_RANK];
#3628     start[j] = 0;
#3631        err = nc_get_vara_longlong(BAD_IDistartedgevalue);
#3634        err = nc_get_vara_longlong(ncidBAD_VARIDstartedgevalue);
#3638     start[j] = var_shape[i][j];
#3639     err = nc_get_vara_longlong(ncidistartedgevalue);
#3642     start[j] = 0;
#3644     err = nc_get_vara_longlong(ncidistartedgevalue);
#3655     err = nc_get_vara_longlong(BAD_IDistartedgevalue);
#3658     err = nc_get_vara_longlong(ncidBAD_VARIDstartedgevalue);
#3661     err = nc_get_vara_longlong(ncidistartedgevalue);
#3684                    start[j] = 0;
#3687                    start[j] = mid[j];
#3698                    index[d] += start[d];
#3710 err = nc_get_vara_longlong(ncidistartedgevalue);
#3768    size_t start[MAX_RANK];
#3784     start[j] = 0;
#3787        err = nc_get_vara_ulonglong(BAD_IDistartedgevalue);
#3790        err = nc_get_vara_ulonglong(ncidBAD_VARIDstartedgevalue);
#3794     start[j] = var_shape[i][j];
#3795     err = nc_get_vara_ulonglong(ncidistartedgevalue);
#3798     start[j] = 0;
#3800     err = nc_get_vara_ulonglong(ncidistartedgevalue);
#3811     err = nc_get_vara_ulonglong(BAD_IDistartedgevalue);
#3814     err = nc_get_vara_ulonglong(ncidBAD_VARIDstartedgevalue);
#3817     err = nc_get_vara_ulonglong(ncidistartedgevalue);
#3840                    start[j] = 0;
#3843                    start[j] = mid[j];
#3854                    index[d] += start[d];
#3866 err = nc_get_vara_ulonglong(ncidistartedgevalue);
#3929    size_t start[MAX_RANK];
#3949            start[j] = 0;
#3953        err = nc_get_vars_text(BAD_IDistartedgestridevalue);
#3956        err = nc_get_vars_text(ncidBAD_VARIDstartedgestridevalue);
#3960            start[j] = var_shape[i][j];
#3961            err = nc_get_vars_text(ncidistartedgestridevalue);
#3968            start[j] = 0;
#3970            err = nc_get_vars_text(ncidistartedgestridevalue);
#3975            err = nc_get_vars_text(ncidistartedgestridevalue);
#3994                    start[j] = 0;
#3997                    start[j] = mid[j];
#4011                    index[j] += start[j];
#4103    size_t start[MAX_RANK];
#4123            start[j] = 0;
#4127        err = nc_get_vars_uchar(BAD_IDistartedgestridevalue);
#4130        err = nc_get_vars_uchar(ncidBAD_VARIDstartedgestridevalue);
#4134            start[j] = var_shape[i][j];
#4135            err = nc_get_vars_uchar(ncidistartedgestridevalue);
#4142            start[j] = 0;
#4144            err = nc_get_vars_uchar(ncidistartedgestridevalue);
#4149            err = nc_get_vars_uchar(ncidistartedgestridevalue);
#4168                    start[j] = 0;
#4171                    start[j] = mid[j];
#4185                    index[j] += start[j];
#4277    size_t start[MAX_RANK];
#4297            start[j] = 0;
#4301        err = nc_get_vars_schar(BAD_IDistartedgestridevalue);
#4304        err = nc_get_vars_schar(ncidBAD_VARIDstartedgestridevalue);
#4308            start[j] = var_shape[i][j];
#4309            err = nc_get_vars_schar(ncidistartedgestridevalue);
#4316            start[j] = 0;
#4318            err = nc_get_vars_schar(ncidistartedgestridevalue);
#4323            err = nc_get_vars_schar(ncidistartedgestridevalue);
#4342                    start[j] = 0;
#4345                    start[j] = mid[j];
#4359                    index[j] += start[j];
#4451    size_t start[MAX_RANK];
#4471            start[j] = 0;
#4475        err = nc_get_vars_short(BAD_IDistartedgestridevalue);
#4478        err = nc_get_vars_short(ncidBAD_VARIDstartedgestridevalue);
#4482            start[j] = var_shape[i][j];
#4483            err = nc_get_vars_short(ncidistartedgestridevalue);
#4490            start[j] = 0;
#4492            err = nc_get_vars_short(ncidistartedgestridevalue);
#4497            err = nc_get_vars_short(ncidistartedgestridevalue);
#4516                    start[j] = 0;
#4519                    start[j] = mid[j];
#4533                    index[j] += start[j];
#4625    size_t start[MAX_RANK];
#4645            start[j] = 0;
#4649        err = nc_get_vars_int(BAD_IDistartedgestridevalue);
#4652        err = nc_get_vars_int(ncidBAD_VARIDstartedgestridevalue);
#4656            start[j] = var_shape[i][j];
#4657            err = nc_get_vars_int(ncidistartedgestridevalue);
#4664            start[j] = 0;
#4666            err = nc_get_vars_int(ncidistartedgestridevalue);
#4671            err = nc_get_vars_int(ncidistartedgestridevalue);
#4690                    start[j] = 0;
#4693                    start[j] = mid[j];
#4707                    index[j] += start[j];
#4799    size_t start[MAX_RANK];
#4819            start[j] = 0;
#4823        err = nc_get_vars_long(BAD_IDistartedgestridevalue);
#4826        err = nc_get_vars_long(ncidBAD_VARIDstartedgestridevalue);
#4830            start[j] = var_shape[i][j];
#4831            err = nc_get_vars_long(ncidistartedgestridevalue);
#4838            start[j] = 0;
#4840            err = nc_get_vars_long(ncidistartedgestridevalue);
#4845            err = nc_get_vars_long(ncidistartedgestridevalue);
#4864                    start[j] = 0;
#4867                    start[j] = mid[j];
#4881                    index[j] += start[j];
#4973    size_t start[MAX_RANK];
#4993            start[j] = 0;
#4997        err = nc_get_vars_float(BAD_IDistartedgestridevalue);
#5000        err = nc_get_vars_float(ncidBAD_VARIDstartedgestridevalue);
#5004            start[j] = var_shape[i][j];
#5005            err = nc_get_vars_float(ncidistartedgestridevalue);
#5012            start[j] = 0;
#5014            err = nc_get_vars_float(ncidistartedgestridevalue);
#5019            err = nc_get_vars_float(ncidistartedgestridevalue);
#5038                    start[j] = 0;
#5041                    start[j] = mid[j];
#5055                    index[j] += start[j];
#5147    size_t start[MAX_RANK];
#5167            start[j] = 0;
#5171        err = nc_get_vars_double(BAD_IDistartedgestridevalue);
#5174        err = nc_get_vars_double(ncidBAD_VARIDstartedgestridevalue);
#5178            start[j] = var_shape[i][j];
#5179            err = nc_get_vars_double(ncidistartedgestridevalue);
#5186            start[j] = 0;
#5188            err = nc_get_vars_double(ncidistartedgestridevalue);
#5193            err = nc_get_vars_double(ncidistartedgestridevalue);
#5212                    start[j] = 0;
#5215                    start[j] = mid[j];
#5229                    index[j] += start[j];
#5321    size_t start[MAX_RANK];
#5341            start[j] = 0;
#5345        err = nc_get_vars_ushort(BAD_IDistartedgestridevalue);
#5348        err = nc_get_vars_ushort(ncidBAD_VARIDstartedgestridevalue);
#5352            start[j] = var_shape[i][j];
#5353            err = nc_get_vars_ushort(ncidistartedgestridevalue);
#5360            start[j] = 0;
#5362            err = nc_get_vars_ushort(ncidistartedgestridevalue);
#5367            err = nc_get_vars_ushort(ncidistartedgestridevalue);
#5386                    start[j] = 0;
#5389                    start[j] = mid[j];
#5403                    index[j] += start[j];
#5495    size_t start[MAX_RANK];
#5515            start[j] = 0;
#5519        err = nc_get_vars_uint(BAD_IDistartedgestridevalue);
#5522        err = nc_get_vars_uint(ncidBAD_VARIDstartedgestridevalue);
#5526            start[j] = var_shape[i][j];
#5527            err = nc_get_vars_uint(ncidistartedgestridevalue);
#5534            start[j] = 0;
#5536            err = nc_get_vars_uint(ncidistartedgestridevalue);
#5541            err = nc_get_vars_uint(ncidistartedgestridevalue);
#5560                    start[j] = 0;
#5563                    start[j] = mid[j];
#5577                    index[j] += start[j];
#5669    size_t start[MAX_RANK];
#5689            start[j] = 0;
#5693        err = nc_get_vars_longlong(BAD_IDistartedgestridevalue);
#5696        err = nc_get_vars_longlong(ncidBAD_VARIDstartedgestridevalue);
#5700            start[j] = var_shape[i][j];
#5701            err = nc_get_vars_longlong(ncidistartedgestridevalue);
#5708            start[j] = 0;
#5710            err = nc_get_vars_longlong(ncidistartedgestridevalue);
#5715            err = nc_get_vars_longlong(ncidistartedgestridevalue);
#5734                    start[j] = 0;
#5737                    start[j] = mid[j];
#5751                    index[j] += start[j];
#5843    size_t start[MAX_RANK];
#5863            start[j] = 0;
#5867        err = nc_get_vars_ulonglong(BAD_IDistartedgestridevalue);
#5870        err = nc_get_vars_ulonglong(ncidBAD_VARIDstartedgestridevalue);
#5874            start[j] = var_shape[i][j];
#5875            err = nc_get_vars_ulonglong(ncidistartedgestridevalue);
#5882            start[j] = 0;
#5884            err = nc_get_vars_ulonglong(ncidistartedgestridevalue);
#5889            err = nc_get_vars_ulonglong(ncidistartedgestridevalue);
#5908                    start[j] = 0;
#5911                    start[j] = mid[j];
#5925                    index[j] += start[j];
#6020    size_t start[MAX_RANK];
#6041            start[j] = 0;
#6046        err = nc_get_varm_text(BAD_IDistartedgestrideimapvalue);
#6049        err = nc_get_varm_text(ncidBAD_VARIDstartedgestrideimapvalue);
#6053            start[j] = var_shape[i][j];
#6054            err = nc_get_varm_text(ncidistartedgestrideimapvalue);
#6061            start[j] = 0;
#6063            err = nc_get_varm_text(ncidistartedgestrideimapvalue);
#6068            err = nc_get_varm_text(ncidistartedgestrideimapvalue);
#6087                    start[j] = 0;
#6090                    start[j] = mid[j];
#6104                    index[j] += start[j];
#6202    size_t start[MAX_RANK];
#6223            start[j] = 0;
#6228        err = nc_get_varm_uchar(BAD_IDistartedgestrideimapvalue);
#6231        err = nc_get_varm_uchar(ncidBAD_VARIDstartedgestrideimapvalue);
#6235            start[j] = var_shape[i][j];
#6236            err = nc_get_varm_uchar(ncidistartedgestrideimapvalue);
#6243            start[j] = 0;
#6245            err = nc_get_varm_uchar(ncidistartedgestrideimapvalue);
#6250            err = nc_get_varm_uchar(ncidistartedgestrideimapvalue);
#6269                    start[j] = 0;
#6272                    start[j] = mid[j];
#6286                    index[j] += start[j];
#6384    size_t start[MAX_RANK];
#6405            start[j] = 0;
#6410        err = nc_get_varm_schar(BAD_IDistartedgestrideimapvalue);
#6413        err = nc_get_varm_schar(ncidBAD_VARIDstartedgestrideimapvalue);
#6417            start[j] = var_shape[i][j];
#6418            err = nc_get_varm_schar(ncidistartedgestrideimapvalue);
#6425            start[j] = 0;
#6427            err = nc_get_varm_schar(ncidistartedgestrideimapvalue);
#6432            err = nc_get_varm_schar(ncidistartedgestrideimapvalue);
#6451                    start[j] = 0;
#6454                    start[j] = mid[j];
#6468                    index[j] += start[j];
#6566    size_t start[MAX_RANK];
#6587            start[j] = 0;
#6592        err = nc_get_varm_short(BAD_IDistartedgestrideimapvalue);
#6595        err = nc_get_varm_short(ncidBAD_VARIDstartedgestrideimapvalue);
#6599            start[j] = var_shape[i][j];
#6600            err = nc_get_varm_short(ncidistartedgestrideimapvalue);
#6607            start[j] = 0;
#6609            err = nc_get_varm_short(ncidistartedgestrideimapvalue);
#6614            err = nc_get_varm_short(ncidistartedgestrideimapvalue);
#6633                    start[j] = 0;
#6636                    start[j] = mid[j];
#6650                    index[j] += start[j];
#6748    size_t start[MAX_RANK];
#6769            start[j] = 0;
#6774        err = nc_get_varm_int(BAD_IDistartedgestrideimapvalue);
#6777        err = nc_get_varm_int(ncidBAD_VARIDstartedgestrideimapvalue);
#6781            start[j] = var_shape[i][j];
#6782            err = nc_get_varm_int(ncidistartedgestrideimapvalue);
#6789            start[j] = 0;
#6791            err = nc_get_varm_int(ncidistartedgestrideimapvalue);
#6796            err = nc_get_varm_int(ncidistartedgestrideimapvalue);
#6815                    start[j] = 0;
#6818                    start[j] = mid[j];
#6832                    index[j] += start[j];
#6930    size_t start[MAX_RANK];
#6951            start[j] = 0;
#6956        err = nc_get_varm_long(BAD_IDistartedgestrideimapvalue);
#6959        err = nc_get_varm_long(ncidBAD_VARIDstartedgestrideimapvalue);
#6963            start[j] = var_shape[i][j];
#6964            err = nc_get_varm_long(ncidistartedgestrideimapvalue);
#6971            start[j] = 0;
#6973            err = nc_get_varm_long(ncidistartedgestrideimapvalue);
#6978            err = nc_get_varm_long(ncidistartedgestrideimapvalue);
#6997                    start[j] = 0;
#7000                    start[j] = mid[j];
#7014                    index[j] += start[j];
#7112    size_t start[MAX_RANK];
#7133            start[j] = 0;
#7138        err = nc_get_varm_float(BAD_IDistartedgestrideimapvalue);
#7141        err = nc_get_varm_float(ncidBAD_VARIDstartedgestrideimapvalue);
#7145            start[j] = var_shape[i][j];
#7146            err = nc_get_varm_float(ncidistartedgestrideimapvalue);
#7153            start[j] = 0;
#7155            err = nc_get_varm_float(ncidistartedgestrideimapvalue);
#7160            err = nc_get_varm_float(ncidistartedgestrideimapvalue);
#7179                    start[j] = 0;
#7182                    start[j] = mid[j];
#7196                    index[j] += start[j];
#7294    size_t start[MAX_RANK];
#7315            start[j] = 0;
#7320        err = nc_get_varm_double(BAD_IDistartedgestrideimapvalue);
#7323        err = nc_get_varm_double(ncidBAD_VARIDstartedgestrideimapvalue);
#7327            start[j] = var_shape[i][j];
#7328            err = nc_get_varm_double(ncidistartedgestrideimapvalue);
#7335            start[j] = 0;
#7337            err = nc_get_varm_double(ncidistartedgestrideimapvalue);
#7342            err = nc_get_varm_double(ncidistartedgestrideimapvalue);
#7361                    start[j] = 0;
#7364                    start[j] = mid[j];
#7378                    index[j] += start[j];
#7476    size_t start[MAX_RANK];
#7497            start[j] = 0;
#7502        err = nc_get_varm_ushort(BAD_IDistartedgestrideimapvalue);
#7505        err = nc_get_varm_ushort(ncidBAD_VARIDstartedgestrideimapvalue);
#7509            start[j] = var_shape[i][j];
#7510            err = nc_get_varm_ushort(ncidistartedgestrideimapvalue);
#7517            start[j] = 0;
#7519            err = nc_get_varm_ushort(ncidistartedgestrideimapvalue);
#7524            err = nc_get_varm_ushort(ncidistartedgestrideimapvalue);
#7543                    start[j] = 0;
#7546                    start[j] = mid[j];
#7560                    index[j] += start[j];
#7658    size_t start[MAX_RANK];
#7679            start[j] = 0;
#7684        err = nc_get_varm_uint(BAD_IDistartedgestrideimapvalue);
#7687        err = nc_get_varm_uint(ncidBAD_VARIDstartedgestrideimapvalue);
#7691            start[j] = var_shape[i][j];
#7692            err = nc_get_varm_uint(ncidistartedgestrideimapvalue);
#7699            start[j] = 0;
#7701            err = nc_get_varm_uint(ncidistartedgestrideimapvalue);
#7706            err = nc_get_varm_uint(ncidistartedgestrideimapvalue);
#7725                    start[j] = 0;
#7728                    start[j] = mid[j];
#7742                    index[j] += start[j];
#7840    size_t start[MAX_RANK];
#7861            start[j] = 0;
#7866        err = nc_get_varm_longlong(BAD_IDistartedgestrideimapvalue);
#7869        err = nc_get_varm_longlong(ncidBAD_VARIDstartedgestrideimapvalue);
#7873            start[j] = var_shape[i][j];
#7874            err = nc_get_varm_longlong(ncidistartedgestrideimapvalue);
#7881            start[j] = 0;
#7883            err = nc_get_varm_longlong(ncidistartedgestrideimapvalue);
#7888            err = nc_get_varm_longlong(ncidistartedgestrideimapvalue);
#7907                    start[j] = 0;
#7910                    start[j] = mid[j];
#7924                    index[j] += start[j];
#8022    size_t start[MAX_RANK];
#8043            start[j] = 0;
#8048        err = nc_get_varm_ulonglong(BAD_IDistartedgestrideimapvalue);
#8051        err = nc_get_varm_ulonglong(ncidBAD_VARIDstartedgestrideimapvalue);
#8055            start[j] = var_shape[i][j];
#8056            err = nc_get_varm_ulonglong(ncidistartedgestrideimapvalue);
#8063            start[j] = 0;
#8065            err = nc_get_varm_ulonglong(ncidistartedgestrideimapvalue);
#8070            err = nc_get_varm_ulonglong(ncidistartedgestrideimapvalue);
#8089                    start[j] = 0;
#8092                    start[j] = mid[j];
#8106                    index[j] += start[j];
test_nstride_cached.c#86    size_t start[5], count[5];
#114        start[idim] = 0;
#145    start[0] = 0;
#146    start[1] = 0;
#147    start[2] = 0;
#148    start[3] = 0;
#159 idim,start[idim],idim,count[idim],idim,stride[idim]);
#162    ncstatus = nc_get_vars_float (ncidvaridstartcountstride, (float*) dat);
#195    start[0] = 0;
#196    start[1] = 0;
#197    start[2] = 0;
#198    start[3] = 0;
#209 idimstart[idim], idimcount[idim], idimstride[idim]);
#212    ncstatus = nc_get_vars_float (ncidvaridstartcountstride, (float*) dat);
#254    start[0] = 250;
#255    start[1] = 704;
#266 idim,start[idim],idim,count[idim],idim,stride[idim]);
#270    ncstatus = nc_get_vars_float (ncidvaridstartcountstride,  (float*) sdat);
test_partvar.c#44    size_t* start;
#56static void odom_set(Odomodom, size_t* start, size_t* count);
#62static int check(float*, size_t* start, size_t* count);
#77void dump(float* source, size_t start, size_t count)
#81    printf("start=%lu count=%lu\n",(unsigned long)start,(unsigned long)count);
#83 printf(" %g",source[start+i]);
#95    size_t start[RANK];
#128    memcpy(start,start0,sizeof(start0));
#132    for(offset=0;start[0] < count0[0];start[0]++) {
#136        if((retval = nc_get_vara_float(ncid,varid,start,count,fpos)))
#170check(float* target, size_t* start, size_t* count)
#176    odom_set(odom,start,count);
#199    odom->start = (size_t*)calloc(sizeof(size_t)*rank,1);
#209    free(odom->start);
#215odom_set(Odomodom, size_t* start, size_t* count)
#220        odom->start[i] = start[i];
#224        odom->index[i] = odom->start[i];
#225        odom->stop[i] =  odom->start[i] + odom->count[i];
#244 odom->index[i] = odom->start[i]; /* reset this position*/
test_put.c#4926    size_t start[MAX_RANK];
#4965            start[j] = 0;
#4968        err = nc_put_vara_text(BAD_IDistartedgevalue);
#4971        err = nc_put_vara_text(ncidBAD_VARIDstartedgevalue);
#4976 start[j] = var_shape[i][j];
#4977 err = nc_put_vara_text(ncidistartedgevalue);
#4980 start[j] = 0;
#4982 err = nc_put_vara_text(ncidistartedgevalue);
#5018     start[j] = 0;
#5021     start[j] = mid[j];
#5031     index[d] += start[d];
#5039 err = nc_put_vara_text(ncidistartedgevalue);
#5077    size_t start[MAX_RANK];
#5116            start[j] = 0;
#5119        err = nc_put_vara_uchar(BAD_IDistartedgevalue);
#5122        err = nc_put_vara_uchar(ncidBAD_VARIDstartedgevalue);
#5127 start[j] = var_shape[i][j];
#5128 err = nc_put_vara_uchar(ncidistartedgevalue);
#5131 start[j] = 0;
#5133 err = nc_put_vara_uchar(ncidistartedgevalue);
#5169     start[j] = 0;
#5172     start[j] = mid[j];
#5182     index[d] += start[d];
#5190 err = nc_put_vara_uchar(ncidistartedgevalue);
#5228    size_t start[MAX_RANK];
#5267            start[j] = 0;
#5270        err = nc_put_vara_schar(BAD_IDistartedgevalue);
#5273        err = nc_put_vara_schar(ncidBAD_VARIDstartedgevalue);
#5278 start[j] = var_shape[i][j];
#5279 err = nc_put_vara_schar(ncidistartedgevalue);
#5282 start[j] = 0;
#5284 err = nc_put_vara_schar(ncidistartedgevalue);
#5320     start[j] = 0;
#5323     start[j] = mid[j];
#5333     index[d] += start[d];
#5341 err = nc_put_vara_schar(ncidistartedgevalue);
#5379    size_t start[MAX_RANK];
#5418            start[j] = 0;
#5421        err = nc_put_vara_short(BAD_IDistartedgevalue);
#5424        err = nc_put_vara_short(ncidBAD_VARIDstartedgevalue);
#5429 start[j] = var_shape[i][j];
#5430 err = nc_put_vara_short(ncidistartedgevalue);
#5433 start[j] = 0;
#5435 err = nc_put_vara_short(ncidistartedgevalue);
#5471     start[j] = 0;
#5474     start[j] = mid[j];
#5484     index[d] += start[d];
#5492 err = nc_put_vara_short(ncidistartedgevalue);
#5530    size_t start[MAX_RANK];
#5569            start[j] = 0;
#5572        err = nc_put_vara_int(BAD_IDistartedgevalue);
#5575        err = nc_put_vara_int(ncidBAD_VARIDstartedgevalue);
#5580 start[j] = var_shape[i][j];
#5581 err = nc_put_vara_int(ncidistartedgevalue);
#5584 start[j] = 0;
#5586 err = nc_put_vara_int(ncidistartedgevalue);
#5622     start[j] = 0;
#5625     start[j] = mid[j];
#5635     index[d] += start[d];
#5643 err = nc_put_vara_int(ncidistartedgevalue);
#5681    size_t start[MAX_RANK];
#5720            start[j] = 0;
#5723        err = nc_put_vara_long(BAD_IDistartedgevalue);
#5726        err = nc_put_vara_long(ncidBAD_VARIDstartedgevalue);
#5731 start[j] = var_shape[i][j];
#5732 err = nc_put_vara_long(ncidistartedgevalue);
#5735 start[j] = 0;
#5737 err = nc_put_vara_long(ncidistartedgevalue);
#5773     start[j] = 0;
#5776     start[j] = mid[j];
#5786     index[d] += start[d];
#5794 err = nc_put_vara_long(ncidistartedgevalue);
#5832    size_t start[MAX_RANK];
#5871            start[j] = 0;
#5874        err = nc_put_vara_float(BAD_IDistartedgevalue);
#5877        err = nc_put_vara_float(ncidBAD_VARIDstartedgevalue);
#5882 start[j] = var_shape[i][j];
#5883 err = nc_put_vara_float(ncidistartedgevalue);
#5886 start[j] = 0;
#5888 err = nc_put_vara_float(ncidistartedgevalue);
#5924     start[j] = 0;
#5927     start[j] = mid[j];
#5937     index[d] += start[d];
#5945 err = nc_put_vara_float(ncidistartedgevalue);
#5983    size_t start[MAX_RANK];
#6022            start[j] = 0;
#6025        err = nc_put_vara_double(BAD_IDistartedgevalue);
#6028        err = nc_put_vara_double(ncidBAD_VARIDstartedgevalue);
#6033 start[j] = var_shape[i][j];
#6034 err = nc_put_vara_double(ncidistartedgevalue);
#6037 start[j] = 0;
#6039 err = nc_put_vara_double(ncidistartedgevalue);
#6075     start[j] = 0;
#6078     start[j] = mid[j];
#6088     index[d] += start[d];
#6096 err = nc_put_vara_double(ncidistartedgevalue);
#6134    size_t start[MAX_RANK];
#6173            start[j] = 0;
#6176        err = nc_put_vara_ushort(BAD_IDistartedgevalue);
#6179        err = nc_put_vara_ushort(ncidBAD_VARIDstartedgevalue);
#6184 start[j] = var_shape[i][j];
#6185 err = nc_put_vara_ushort(ncidistartedgevalue);
#6188 start[j] = 0;
#6190 err = nc_put_vara_ushort(ncidistartedgevalue);
#6226     start[j] = 0;
#6229     start[j] = mid[j];
#6239     index[d] += start[d];
#6247 err = nc_put_vara_ushort(ncidistartedgevalue);
#6285    size_t start[MAX_RANK];
#6324            start[j] = 0;
#6327        err = nc_put_vara_uint(BAD_IDistartedgevalue);
#6330        err = nc_put_vara_uint(ncidBAD_VARIDstartedgevalue);
#6335 start[j] = var_shape[i][j];
#6336 err = nc_put_vara_uint(ncidistartedgevalue);
#6339 start[j] = 0;
#6341 err = nc_put_vara_uint(ncidistartedgevalue);
#6377     start[j] = 0;
#6380     start[j] = mid[j];
#6390     index[d] += start[d];
#6398 err = nc_put_vara_uint(ncidistartedgevalue);
#6436    size_t start[MAX_RANK];
#6475            start[j] = 0;
#6478        err = nc_put_vara_longlong(BAD_IDistartedgevalue);
#6481        err = nc_put_vara_longlong(ncidBAD_VARIDstartedgevalue);
#6486 start[j] = var_shape[i][j];
#6487 err = nc_put_vara_longlong(ncidistartedgevalue);
#6490 start[j] = 0;
#6492 err = nc_put_vara_longlong(ncidistartedgevalue);
#6528     start[j] = 0;
#6531     start[j] = mid[j];
#6541     index[d] += start[d];
#6549 err = nc_put_vara_longlong(ncidistartedgevalue);
#6587    size_t start[MAX_RANK];
#6626            start[j] = 0;
#6629        err = nc_put_vara_ulonglong(BAD_IDistartedgevalue);
#6632        err = nc_put_vara_ulonglong(ncidBAD_VARIDstartedgevalue);
#6637 start[j] = var_shape[i][j];
#6638 err = nc_put_vara_ulonglong(ncidistartedgevalue);
#6641 start[j] = 0;
#6643 err = nc_put_vara_ulonglong(ncidistartedgevalue);
#6679     start[j] = 0;
#6682     start[j] = mid[j];
#6692     index[d] += start[d];
#6700 err = nc_put_vara_ulonglong(ncidistartedgevalue);
#6743    size_t start[MAX_RANK];
#6785     start[j] = 0;
#6789 err = nc_put_vars_text(BAD_IDistartedgestridevalue);
#6792 err = nc_put_vars_text(ncidBAD_VARIDstartedgestridevalue);
#6797 start[j] = var_shape[i][j] + 1;
#6798 err = nc_put_vars_text(ncidistartedgestridevalue);
#6805 start[j] = 0;
#6807 err = nc_put_vars_text(ncidistartedgestridevalue);
#6812 err = nc_put_vars_text(ncidistartedgestridevalue);
#6832     start[j] = 0;
#6835     start[j] = mid[j];
#6849     index[j] += start[j];
#6915    size_t start[MAX_RANK];
#6957     start[j] = 0;
#6961 err = nc_put_vars_uchar(BAD_IDistartedgestridevalue);
#6964 err = nc_put_vars_uchar(ncidBAD_VARIDstartedgestridevalue);
#6969 start[j] = var_shape[i][j] + 1;
#6970 err = nc_put_vars_uchar(ncidistartedgestridevalue);
#6977 start[j] = 0;
#6979 err = nc_put_vars_uchar(ncidistartedgestridevalue);
#6984 err = nc_put_vars_uchar(ncidistartedgestridevalue);
#7004     start[j] = 0;
#7007     start[j] = mid[j];
#7021     index[j] += start[j];
#7087    size_t start[MAX_RANK];
#7129     start[j] = 0;
#7133 err = nc_put_vars_schar(BAD_IDistartedgestridevalue);
#7136 err = nc_put_vars_schar(ncidBAD_VARIDstartedgestridevalue);
#7141 start[j] = var_shape[i][j] + 1;
#7142 err = nc_put_vars_schar(ncidistartedgestridevalue);
#7149 start[j] = 0;
#7151 err = nc_put_vars_schar(ncidistartedgestridevalue);
#7156 err = nc_put_vars_schar(ncidistartedgestridevalue);
#7176     start[j] = 0;
#7179     start[j] = mid[j];
#7193     index[j] += start[j];
#7259    size_t start[MAX_RANK];
#7301     start[j] = 0;
#7305 err = nc_put_vars_short(BAD_IDistartedgestridevalue);
#7308 err = nc_put_vars_short(ncidBAD_VARIDstartedgestridevalue);
#7313 start[j] = var_shape[i][j] + 1;
#7314 err = nc_put_vars_short(ncidistartedgestridevalue);
#7321 start[j] = 0;
#7323 err = nc_put_vars_short(ncidistartedgestridevalue);
#7328 err = nc_put_vars_short(ncidistartedgestridevalue);
#7348     start[j] = 0;
#7351     start[j] = mid[j];
#7365     index[j] += start[j];
#7431    size_t start[MAX_RANK];
#7473     start[j] = 0;
#7477 err = nc_put_vars_int(BAD_IDistartedgestridevalue);
#7480 err = nc_put_vars_int(ncidBAD_VARIDstartedgestridevalue);
#7485 start[j] = var_shape[i][j] + 1;
#7486 err = nc_put_vars_int(ncidistartedgestridevalue);
#7493 start[j] = 0;
#7495 err = nc_put_vars_int(ncidistartedgestridevalue);
#7500 err = nc_put_vars_int(ncidistartedgestridevalue);
#7520     start[j] = 0;
#7523     start[j] = mid[j];
#7537     index[j] += start[j];
#7603    size_t start[MAX_RANK];
#7645     start[j] = 0;
#7649 err = nc_put_vars_long(BAD_IDistartedgestridevalue);
#7652 err = nc_put_vars_long(ncidBAD_VARIDstartedgestridevalue);
#7657 start[j] = var_shape[i][j] + 1;
#7658 err = nc_put_vars_long(ncidistartedgestridevalue);
#7665 start[j] = 0;
#7667 err = nc_put_vars_long(ncidistartedgestridevalue);
#7672 err = nc_put_vars_long(ncidistartedgestridevalue);
#7692     start[j] = 0;
#7695     start[j] = mid[j];
#7709     index[j] += start[j];
#7775    size_t start[MAX_RANK];
#7817     start[j] = 0;
#7821 err = nc_put_vars_float(BAD_IDistartedgestridevalue);
#7824 err = nc_put_vars_float(ncidBAD_VARIDstartedgestridevalue);
#7829 start[j] = var_shape[i][j] + 1;
#7830 err = nc_put_vars_float(ncidistartedgestridevalue);
#7837 start[j] = 0;
#7839 err = nc_put_vars_float(ncidistartedgestridevalue);
#7844 err = nc_put_vars_float(ncidistartedgestridevalue);
#7864     start[j] = 0;
#7867     start[j] = mid[j];
#7881     index[j] += start[j];
#7947    size_t start[MAX_RANK];
#7989     start[j] = 0;
#7993 err = nc_put_vars_double(BAD_IDistartedgestridevalue);
#7996 err = nc_put_vars_double(ncidBAD_VARIDstartedgestridevalue);
#8001 start[j] = var_shape[i][j] + 1;
#8002 err = nc_put_vars_double(ncidistartedgestridevalue);
#8009 start[j] = 0;
#8011 err = nc_put_vars_double(ncidistartedgestridevalue);
#8016 err = nc_put_vars_double(ncidistartedgestridevalue);
#8036     start[j] = 0;
#8039     start[j] = mid[j];
#8053     index[j] += start[j];
#8119    size_t start[MAX_RANK];
#8161     start[j] = 0;
#8165 err = nc_put_vars_ushort(BAD_IDistartedgestridevalue);
#8168 err = nc_put_vars_ushort(ncidBAD_VARIDstartedgestridevalue);
#8173 start[j] = var_shape[i][j] + 1;
#8174 err = nc_put_vars_ushort(ncidistartedgestridevalue);
#8181 start[j] = 0;
#8183 err = nc_put_vars_ushort(ncidistartedgestridevalue);
#8188 err = nc_put_vars_ushort(ncidistartedgestridevalue);
#8208     start[j] = 0;
#8211     start[j] = mid[j];
#8225     index[j] += start[j];
#8291    size_t start[MAX_RANK];
#8333     start[j] = 0;
#8337 err = nc_put_vars_uint(BAD_IDistartedgestridevalue);
#8340 err = nc_put_vars_uint(ncidBAD_VARIDstartedgestridevalue);
#8345 start[j] = var_shape[i][j] + 1;
#8346 err = nc_put_vars_uint(ncidistartedgestridevalue);
#8353 start[j] = 0;
#8355 err = nc_put_vars_uint(ncidistartedgestridevalue);
#8360 err = nc_put_vars_uint(ncidistartedgestridevalue);
#8380     start[j] = 0;
#8383     start[j] = mid[j];
#8397     index[j] += start[j];
#8463    size_t start[MAX_RANK];
#8505     start[j] = 0;
#8509 err = nc_put_vars_longlong(BAD_IDistartedgestridevalue);
#8512 err = nc_put_vars_longlong(ncidBAD_VARIDstartedgestridevalue);
#8517 start[j] = var_shape[i][j] + 1;
#8518 err = nc_put_vars_longlong(ncidistartedgestridevalue);
#8525 start[j] = 0;
#8527 err = nc_put_vars_longlong(ncidistartedgestridevalue);
#8532 err = nc_put_vars_longlong(ncidistartedgestridevalue);
#8552     start[j] = 0;
#8555     start[j] = mid[j];
#8569     index[j] += start[j];
#8635    size_t start[MAX_RANK];
#8677     start[j] = 0;
#8681 err = nc_put_vars_ulonglong(BAD_IDistartedgestridevalue);
#8684 err = nc_put_vars_ulonglong(ncidBAD_VARIDstartedgestridevalue);
#8689 start[j] = var_shape[i][j] + 1;
#8690 err = nc_put_vars_ulonglong(ncidistartedgestridevalue);
#8697 start[j] = 0;
#8699 err = nc_put_vars_ulonglong(ncidistartedgestridevalue);
#8704 err = nc_put_vars_ulonglong(ncidistartedgestridevalue);
#8724     start[j] = 0;
#8727     start[j] = mid[j];
#8741     index[j] += start[j];
#8810    size_t start[MAX_RANK];
#8853     start[j] = 0;
#8858 err = nc_put_varm_text(BAD_IDistartedgestrideimapvalue);
#8861 err = nc_put_varm_text(ncidBAD_VARIDstartedgestrideimapvalue);
#8866 start[j] = var_shape[i][j] + 1;
#8867 err = nc_put_varm_text(ncidistartedgestrideimapvalue);
#8874 start[j] = 0;
#8876 err = nc_put_varm_text(ncidistartedgestrideimapvalue);
#8881 err = nc_put_varm_text(ncidistartedgestrideimapvalue);
#8901     start[j] = 0;
#8904     start[j] = mid[j];
#8918                    index[j] += start[j];
#8990    size_t start[MAX_RANK];
#9033     start[j] = 0;
#9038 err = nc_put_varm_uchar(BAD_IDistartedgestrideimapvalue);
#9041 err = nc_put_varm_uchar(ncidBAD_VARIDstartedgestrideimapvalue);
#9046 start[j] = var_shape[i][j] + 1;
#9047 err = nc_put_varm_uchar(ncidistartedgestrideimapvalue);
#9054 start[j] = 0;
#9056 err = nc_put_varm_uchar(ncidistartedgestrideimapvalue);
#9061 err = nc_put_varm_uchar(ncidistartedgestrideimapvalue);
#9081     start[j] = 0;
#9084     start[j] = mid[j];
#9098                    index[j] += start[j];
#9170    size_t start[MAX_RANK];
#9213     start[j] = 0;
#9218 err = nc_put_varm_schar(BAD_IDistartedgestrideimapvalue);
#9221 err = nc_put_varm_schar(ncidBAD_VARIDstartedgestrideimapvalue);
#9226 start[j] = var_shape[i][j] + 1;
#9227 err = nc_put_varm_schar(ncidistartedgestrideimapvalue);
#9234 start[j] = 0;
#9236 err = nc_put_varm_schar(ncidistartedgestrideimapvalue);
#9241 err = nc_put_varm_schar(ncidistartedgestrideimapvalue);
#9261     start[j] = 0;
#9264     start[j] = mid[j];
#9278                    index[j] += start[j];
#9350    size_t start[MAX_RANK];
#9393     start[j] = 0;
#9398 err = nc_put_varm_short(BAD_IDistartedgestrideimapvalue);
#9401 err = nc_put_varm_short(ncidBAD_VARIDstartedgestrideimapvalue);
#9406 start[j] = var_shape[i][j] + 1;
#9407 err = nc_put_varm_short(ncidistartedgestrideimapvalue);
#9414 start[j] = 0;
#9416 err = nc_put_varm_short(ncidistartedgestrideimapvalue);
#9421 err = nc_put_varm_short(ncidistartedgestrideimapvalue);
#9441     start[j] = 0;
#9444     start[j] = mid[j];
#9458                    index[j] += start[j];
#9530    size_t start[MAX_RANK];
#9573     start[j] = 0;
#9578 err = nc_put_varm_int(BAD_IDistartedgestrideimapvalue);
#9581 err = nc_put_varm_int(ncidBAD_VARIDstartedgestrideimapvalue);
#9586 start[j] = var_shape[i][j] + 1;
#9587 err = nc_put_varm_int(ncidistartedgestrideimapvalue);
#9594 start[j] = 0;
#9596 err = nc_put_varm_int(ncidistartedgestrideimapvalue);
#9601 err = nc_put_varm_int(ncidistartedgestrideimapvalue);
#9621     start[j] = 0;
#9624     start[j] = mid[j];
#9638                    index[j] += start[j];
#9710    size_t start[MAX_RANK];
#9753     start[j] = 0;
#9758 err = nc_put_varm_long(BAD_IDistartedgestrideimapvalue);
#9761 err = nc_put_varm_long(ncidBAD_VARIDstartedgestrideimapvalue);
#9766 start[j] = var_shape[i][j] + 1;
#9767 err = nc_put_varm_long(ncidistartedgestrideimapvalue);
#9774 start[j] = 0;
#9776 err = nc_put_varm_long(ncidistartedgestrideimapvalue);
#9781 err = nc_put_varm_long(ncidistartedgestrideimapvalue);
#9801     start[j] = 0;
#9804     start[j] = mid[j];
#9818                    index[j] += start[j];
#9890    size_t start[MAX_RANK];
#9933     start[j] = 0;
#9938 err = nc_put_varm_float(BAD_IDistartedgestrideimapvalue);
#9941 err = nc_put_varm_float(ncidBAD_VARIDstartedgestrideimapvalue);
#9946 start[j] = var_shape[i][j] + 1;
#9947 err = nc_put_varm_float(ncidistartedgestrideimapvalue);
#9954 start[j] = 0;
#9956 err = nc_put_varm_float(ncidistartedgestrideimapvalue);
#9961 err = nc_put_varm_float(ncidistartedgestrideimapvalue);
#9981     start[j] = 0;
#9984     start[j] = mid[j];
#9998                    index[j] += start[j];
#10070    size_t start[MAX_RANK];
#10113     start[j] = 0;
#10118 err = nc_put_varm_double(BAD_IDistartedgestrideimapvalue);
#10121 err = nc_put_varm_double(ncidBAD_VARIDstartedgestrideimapvalue);
#10126 start[j] = var_shape[i][j] + 1;
#10127 err = nc_put_varm_double(ncidistartedgestrideimapvalue);
#10134 start[j] = 0;
#10136 err = nc_put_varm_double(ncidistartedgestrideimapvalue);
#10141 err = nc_put_varm_double(ncidistartedgestrideimapvalue);
#10161     start[j] = 0;
#10164     start[j] = mid[j];
#10178                    index[j] += start[j];
#10250    size_t start[MAX_RANK];
#10293     start[j] = 0;
#10298 err = nc_put_varm_ushort(BAD_IDistartedgestrideimapvalue);
#10301 err = nc_put_varm_ushort(ncidBAD_VARIDstartedgestrideimapvalue);
#10306 start[j] = var_shape[i][j] + 1;
#10307 err = nc_put_varm_ushort(ncidistartedgestrideimapvalue);
#10314 start[j] = 0;
#10316 err = nc_put_varm_ushort(ncidistartedgestrideimapvalue);
#10321 err = nc_put_varm_ushort(ncidistartedgestrideimapvalue);
#10341     start[j] = 0;
#10344     start[j] = mid[j];
#10358                    index[j] += start[j];
#10430    size_t start[MAX_RANK];
#10473     start[j] = 0;
#10478 err = nc_put_varm_uint(BAD_IDistartedgestrideimapvalue);
#10481 err = nc_put_varm_uint(ncidBAD_VARIDstartedgestrideimapvalue);
#10486 start[j] = var_shape[i][j] + 1;
#10487 err = nc_put_varm_uint(ncidistartedgestrideimapvalue);
#10494 start[j] = 0;
#10496 err = nc_put_varm_uint(ncidistartedgestrideimapvalue);
#10501 err = nc_put_varm_uint(ncidistartedgestrideimapvalue);
#10521     start[j] = 0;
#10524     start[j] = mid[j];
#10538                    index[j] += start[j];
#10610    size_t start[MAX_RANK];
#10653     start[j] = 0;
#10658 err = nc_put_varm_longlong(BAD_IDistartedgestrideimapvalue);
#10661 err = nc_put_varm_longlong(ncidBAD_VARIDstartedgestrideimapvalue);
#10666 start[j] = var_shape[i][j] + 1;
#10667 err = nc_put_varm_longlong(ncidistartedgestrideimapvalue);
#10674 start[j] = 0;
#10676 err = nc_put_varm_longlong(ncidistartedgestrideimapvalue);
#10681 err = nc_put_varm_longlong(ncidistartedgestrideimapvalue);
#10701     start[j] = 0;
#10704     start[j] = mid[j];
#10718                    index[j] += start[j];
#10790    size_t start[MAX_RANK];
#10833     start[j] = 0;
#10838 err = nc_put_varm_ulonglong(BAD_IDistartedgestrideimapvalue);
#10841 err = nc_put_varm_ulonglong(ncidBAD_VARIDstartedgestrideimapvalue);
#10846 start[j] = var_shape[i][j] + 1;
#10847 err = nc_put_varm_ulonglong(ncidistartedgestrideimapvalue);
#10854 start[j] = 0;
#10856 err = nc_put_varm_ulonglong(ncidistartedgestrideimapvalue);
#10861 err = nc_put_varm_ulonglong(ncidistartedgestrideimapvalue);
#10881     start[j] = 0;
#10884     start[j] = mid[j];
#10898                    index[j] += start[j];
test_read.c#912    size_t start[MAX_RANK];
#928            start[j] = 0;
#931        err = nc_get_vara(BAD_IDistartedgebuf);
#934        err = nc_get_vara(ncidBAD_VARIDstartedgebuf);
#938     start[j] = var_shape[i][j];
#939     err = nc_get_vara(ncidistartedgebuf);
#942     start[j] = 0;
#944     err = nc_get_vara(ncidistartedgebuf);
#961                    start[j] = 0;
#964                    start[j] = mid[j];
#972 err = nc_get_vara(ncidistartedgebuf);
#986 index[d] += start[d];
#1035    size_t start[MAX_RANK];
#1055            start[j] = 0;
#1059        err = nc_get_vars(BAD_IDistartedgestridebuf);
#1062        err = nc_get_vars(ncidBAD_VARIDstartedgestridebuf);
#1066     start[j] = var_shape[i][j];
#1067     err = nc_get_vars(ncidistartedgestridebuf);
#1070     start[j] = 0;
#1072     err = nc_get_vars(ncidistartedgestridebuf);
#1077     err = nc_get_vars(ncidistartedgestridebuf);
#1096                    start[j] = 0;
#1099                    start[j] = mid[j];
#1113     index[j] += start[j];
#1201    size_t start[MAX_RANK];
#1222            start[j] = 0;
#1233        err = nc_get_varm(BAD_IDistartedgestrideimapbuf);
#1236        err = nc_get_varm(ncidBAD_VARIDstartedgestrideimapbuf);
#1240     start[j] = var_shape[i][j];
#1241     err = nc_get_varm(ncidistartedgestrideimapbuf);
#1244     start[j] = 0;
#1246     err = nc_get_varm(ncidistartedgestrideimapbuf);
#1251     err = nc_get_varm(ncidistartedgestrideimapbuf);
#1269                    start[j] = 0;
#1272                    start[j] = mid[j];
#1288 index[j] += start[j];
test_vara.c#40    size_t* start;
#52static void odom_set(Odomodom, size_t* start, size_t* count);
#57static int check(size_t* start, size_t* count);
#76    size_t start[RANK];
#102    memcpy(start,start0,sizeof(start0));
#105    if((retval = nc_get_vara_float(ncid,varid,start,count,(float*)threeD)))
#107    if(!check(start,count)) goto fail;
#110    memcpy(start,start0,sizeof(start0));
#114    if((retval = nc_get_vara_float(ncid,varid,start,count,(float*)threeD)))
#116    if(!check(start,count)) goto fail;
#128static int check(size_t* start, size_t* count)
#134    odom_set(odom,start,count);
#155    odom->start = (size_t*)calloc(sizeof(size_t)*rank,1);
#164    free(odom->start);
#170static void odom_set(Odomodom, size_t* start, size_t* count)
#175        odom->start[i] = start[i];
#179        odom->index[i] = odom->start[i];
#180        odom->stop[i] =  odom->start[i] + odom->count[i];
#197 odom->index[i] = odom->start[i]; /* reset this position*/
test_varm3.c#78    size_t start[5], count[5];
#116        start[idim] = 0;
#126    start[1] = 44;
#127    start[2] = 66;
#132    for(i=0;i<ndim;i++) printf(" %d",(int)start[i]);
#144    err = nc_get_vars_float (ncidvaridstartcountstride,
#151    check(err = nc_get_varm_float (ncidvaridstartcountstrideimap,(float*) dat),__FILE__,__LINE__);
#172    start[1] = 44;
#173    start[2] = 66;
#179    for(i=0;i<ndim;i++) printf(" %d",(int)start[i]);
#191    check(err = nc_get_vars_float(ncidvaridstartcountstride,
#197    check(err = nc_get_varm_float(ncidvaridstartcountstrideimap,
#217    start[1] = 44;
#218    start[2] = 66;
#224    for(i=0;i<ndim;i++) printf(" %d",(int)start[i]);
#236    check(err = nc_get_vars_float(ncidvaridstartcountstride,
#242    check(err = nc_get_varm_float(ncidvaridstartcountstrideimap,
test_write.c#797    size_t start[MAX_RANK];
#820            start[j] = 0;
#823        err = nc_put_vara(BAD_IDistartedgebuf);
#826        err = nc_put_vara(ncidBAD_VARIDstartedgebuf);
#831 start[j] = var_shape[i][j];
#832 err = nc_put_vara(ncidistartedgebuf);
#835 start[j] = 0;
#837 err = nc_put_vara(ncidistartedgebuf);
#855                    start[j] = 0;
#858                    start[j] = mid[j];
#869     index[d] += start[d];
#881 err = nc_put_vara(ncidistartedgebuf);
#920    size_t start[MAX_RANK];
#947            start[j] = 0;
#951        err = nc_put_vars(BAD_IDistartedgestridebuf);
#954        err = nc_put_vars(ncidBAD_VARIDstartedgestridebuf);
#959 start[j] = var_shape[i][j];
#960 err = nc_put_vars(ncidistartedgestridebuf);
#963 start[j] = 0;
#965 err = nc_put_vars(ncidistartedgestridebuf);
#970 err = nc_put_vars(ncidistartedgestridebuf);
#989                    start[j] = 0;
#992                    start[j] = mid[j];
#1006                    index[j] += start[j];
#1074    size_t start[MAX_RANK];
#1102            start[j] = 0;
#1126        err = nc_put_varm(BAD_IDistartedgestrideimapbuf);
#1129        err = nc_put_varm(ncidBAD_VARIDstartedgestrideimapbuf);
#1134 start[j] = var_shape[i][j];
#1135 err = nc_put_varm(ncidistartedgestrideimapbuf);
#1138 start[j] = 0;
#1140 err = nc_put_varm(ncidistartedgestrideimapbuf);
#1145 err = nc_put_varm(ncidistartedgestrideimapbuf);
#1164                    start[j] = 0;
#1167                    start[j] = mid[j];
#1183 index[j] += start[j];
tst_ar4.c#105   size_t start[NDIMS3], count[NDIMS3];
#178      start[0] = 0;
#179      start[1] = 0;
#180      start[2] = 0;
#187      if (nc_get_vara_float(ncidvaridstartcountts_data)) ERR_RET;
#194      for (start[1] = 0; start[1] < LAT_LENstart[1]++)
#195  for (start[2] = 1; start[2] < LON_LENstart[2]++)
#196     if (nc_get_vara_float(ncidvaridstartcountts_data)) ERR_RET;
#205      start[0] = 0;
#206      start[1] = 0;
#207      start[2] = 0;
#214      if (nc_get_vara_float(ncidvaridstartcounthor_data)) ERR_RET;
#221      for (start[0] = 1; start[0] < TIME_LENstart[0]++)
#222  if (nc_get_vara_float(ncidvaridstartcounthor_data)) ERR_RET;
tst_ar4_3d.c#113   size_t start[NDIMS3], count[NDIMS3];
#186      start[0] = 0;
#187      start[1] = 0;
#188      start[2] = 0;
#195      if (nc_get_vara_float(ncidvaridstartcountts_data)) ERR_RET;
#202      for (start[1] = 0; start[1] < LAT_LENstart[1]++)
#203  for (start[2] = 1; start[2] < LON_LENstart[2]++)
#204     if (nc_get_vara_float(ncidvaridstartcountts_data)) ERR_RET;
#213      start[0] = 0;
#214      start[1] = 0;
#215      start[2] = 0;
#222      if (nc_get_vara_float(ncidvaridstartcounthor_data)) ERR_RET;
#229      for (start[0] = 1; start[0] < TIME_LENstart[0]++)
#230  if (nc_get_vara_float(ncidvaridstartcounthor_data)) ERR_RET;
tst_ar4_4d.c#220   size_t start[NDIMS4], count[NDIMS4];
#299      start[0] = 0;
#300      start[1] = 0;
#301      start[2] = 0;
#302      start[3] = 0;
#310      if (nc_get_vara_float(ncidvaridstartcountts_data)) ERR_RET;
#317      for (start[1] = 0; read_count < MAX_READ_COUNT && start[1] < LAT_LENstart[1]++)
#318  for (start[2] = 1; read_count < MAX_READ_COUNT && start[2] < LON_LENstart[2]++)
#319     for (start[3] = 1; read_count < MAX_READ_COUNT && start[3] < DEPTH_LENstart[3]++)
#321        if (nc_get_vara_float(ncidvaridstartcountts_data)) ERR_RET;
#333      start[0] = 0;
#334      start[1] = 0;
#335      start[2] = 0;
#336      start[3] = 0;
#344      if (nc_get_vara_float(ncidvaridstartcountvert_data)) ERR_RET;
#368      start[0] = 0;
#369      start[1] = 0;
#370      start[2] = 0;
#371      start[3] = 0;
#379      if (nc_get_vara_float(ncidvaridstartcounthor_data)) ERR_RET;
#386      for (start[0] = 0; read_count < MAX_READ_COUNT && start[0] < TIME_LENstart[0]++)
#387  for (start[1] = 1; read_count < MAX_READ_COUNT && start[1] < DEPTH_LENstart[1]++)
#389     if (nc_get_vara_float(ncidvaridstartcounthor_data)) ERR_RET;
tst_big_rvar.c#47    size_t start[NUMDIMS] = {0, 0, 0, 0};
#70    start[1] = 0;
#71    if (nc_put_vara_schar(ncidvaridstartcount, &data[0][0])) ERR;
#72    start[1] = DIM1 - 1;
#73    if (nc_put_vara_schar(ncidvaridstartcount, &data[0][0])) ERR;
#80    start[1] = 0;
#81    if (nc_get_vara_schar(ncidvaridstartcount, &data[0][0])) ERR;
#88        start[0], ij, (i + j) % 16, data[i][j]);
#94    start[1] = DIM1 - 1;
#95    if (nc_get_vara_schar(ncidvaridstartcount, &data[0][0])) ERR;
#102        start[0], ij, (i + j) % 16, data[i][j]);
tst_big_var2.c#51    size_t start[NUMDIMS] = {0, 0, 0};
#74    start[0] = 0;
#75    if (nc_put_vara_schar(ncidvaridstartcount, &data[0][0])) ERR;
#80    start[0] = DIM0 - 1;
#81    if (nc_put_vara_schar(ncidvaridstartcount, &data[0][0])) ERR;
#88    start[0] = 0;
#89    if (nc_get_vara_schar(ncidvaridstartcount, &data[0][0])) ERR;
#96        start[0], ij, 42, data[i][j]);
#102    start[0] = DIM0 - 1;
#103    if (nc_get_vara_schar(ncidvaridstartcount, &data[0][0])) ERR;
#110      start[0], ij, 19, data[i][j]);
tst_big_var6.c#49    size_t start[NUMDIMS] = {0, 0, 0, 0};
#66    start[0] = 0;
#67    start[1] = 0;
#68    start[2] = 4294;
#71    if (nc_put_vara_short(ncidvaridstartcount, &data[0])) ERR;
#74    start[0] = 0;
#75    start[1] = 1;
#76    start[2] = 0;
#79    if (nc_put_vara_short(ncidvaridstartcount, &data[0])) ERR;
#82    start[0] = 0;
#83    start[1] = 0;
#84    start[2] = 4294;
#85    if (nc_get_vara_short(ncidvaridstartcount, &data[0])) ERR;
#89    start[0], start[1], start[2], jFIRST_VALdata[j]);
tst_bug324.c#81     size_t start[RANK_LAT] = {0} ;
#83     if ( nc_get_vara(ncidlat_idstartcountlat_data) ) ERR;
#88     size_t start[RANK_H] = {0} ;
#90     if ( nc_get_vara(ncidh_idstartcounth_data) ) ERR;
tst_chunks3.c#168    size_t start[3], count[3];
#288    start[0] = 0;
#289    start[1] = 0;
#290    start[2] = 0;
#299 start[0] = i;
#300 if((stat = nc_put_vara(ncidvarid_gstartcount, &varyz[0])))
#311 start[0] = i;
#312 if((stat = nc_put_vara(ncidvarid_kstartcount, &varyz[0])))
#327 start[0] = i;
#328 if((stat = nc_put_vara(ncidvarid_xstartcount, &varyz[0])))
#341    start[0] = 0;
#342    start[1] = 0;
#343    start[2] = 0;
#352 start[1] = i;
#353 if((stat = nc_put_vara(ncidvarid_gstartcount, &varxz[0])))
#364 start[1] = i;
#365 if((stat = nc_put_vara(ncidvarid_kstartcount, &varxz[0])))
#380 start[1] = i;
#381 if((stat = nc_put_vara(ncidvarid_xstartcount, &varxz[0])))
#394    start[0] = 0;
#395    start[1] = 0;
#396    start[2] = 0;
#405 start[2] = i;
#406 if((stat = nc_put_vara(ncidvarid_gstartcount, &varxy[0])))
#417 start[2] = i;
#418 if((stat = nc_put_vara(ncidvarid_kstartcount, &varxy[0])))
#433 start[2] = i;
#434 if((stat = nc_put_vara(ncidvarid_xstartcount, &varxy[0])))
#447    start[0] = 0;
#448    start[1] = 0;
#449    start[2] = 0;
#458 start[0] = i;
#459 if((stat = nc_get_vara(ncidvarid_gstartcount, &varyz[0])))
#470 start[0] = i;
#471 if((stat = nc_get_vara(ncidvarid_kstartcount, &varyz[0])))
#486 start[0] = i;
#487 if((stat = nc_get_vara(ncidvarid_xstartcount, &varyz[0])))
#500    start[0] = 0;
#501    start[1] = 0;
#502    start[2] = 0;
#511 start[1] = i;
#512 if((stat = nc_get_vara(ncidvarid_gstartcount, &varxz[0])))
#523 start[1] = i;
#524 if((stat = nc_get_vara(ncidvarid_kstartcount, &varxz[0])))
#539 start[1] = i;
#540 if((stat = nc_get_vara(ncidvarid_xstartcount, &varxz[0])))
#553    start[0] = 0;
#554    start[1] = 0;
#555    start[2] = 0;
#564 start[2] = i;
#565 if((stat = nc_get_vara(ncidvarid_gstartcount, &varxy[0])))
#576 start[2] = i;
#577 if((stat = nc_get_vara(ncidvarid_kstartcount, &varxy[0])))
#592 start[2] = i;
#593 if((stat = nc_get_vara(ncidvarid_xstartcount, &varxy[0])))
tst_compounds.c#188 size_t start[RANK] = {0};
#197        if (nc_put_vars(ncidvaridstartedgesstridedatas)) ERR;
#205        if (nc_get_vars(ncidvaridstartedgesstridedata)) ERR;
tst_coords3.c#84   size_t start[DATA_NDIMS] = {0, 0, 0}, count[DATA_NDIMS] = {1, YC_LENXC_LEN};
#89   if (nc_get_vara_float(ncid, 0, startcount, (float *)temp_in)) ERR_RET;
#288      size_t start[DATA_NDIMS] = {0, 0, 0}, count[DATA_NDIMS] = {1, YC_LENXC_LEN};
#354      if (nc_put_vara_float(ncid, 0, startcount, (const float *)temp)) ERR;
#383      size_t start[DATA_NDIMS] = {0, 0, 0}, count[DATA_NDIMS] = {1, YC_LENXC_LEN};
#415      if (nc_put_vara_float(ncid, 0, startcount, (const float *)temp)) ERR;
tst_create_files.c#41       size_t start[NDIMS3], count[NDIMS3];
#75       start[0] = 0;
#79   start[d] = 0;
#82       for ( ; start[0] < D0; (start[0])++)
#83   if (nc_put_vara_float(ncidvaridstartcount, (const float *) data))
tst_dims.c#455      size_t start[MAX_DIMS], count[MAX_DIMS];
#487      start[0] = 0;
#489      if (nc_put_vara_ulonglong(ncid, 0, startcountuint64_data)) ERR;
#619      size_t start[MAX_DIMS], count[MAX_DIMS], index[MAX_DIMS];
#645      start[0] = 0;
#647      if (nc_put_vara(ncidhp_varidstartcountdata)) ERR;
#845      size_t start[4], count[4];
#1015      start[0] = start[1] = start[2] = start[3] = 0;
#1020      if (nc_put_vara(ncidpres_varidstartcount,
#1023      if (nc_put_vara(ncidhp_varidstartcount,
tst_dims2.c#250      size_t time_lenbeam_lenstart[NDIMS] = {0, 0}, count[NDIMS] = {1, MAX_VALUES};
#271      if (nc_put_vara_double(ncidvaridstartcountvalue)) ERR;
#278      start[0] = 1;
#279      if (nc_put_vara_double(ncidvaridstartcountvalue)) ERR;
#297      size_t start[] = {0, 0};
#325  if (nc_put_vara_int(ncidvaridstartcountvalue)) ERR;
#326  time_recs = MAX(time_recsstart[0] + count[0]);
#327  beam_recs = MAX(beam_recsstart[1] + count[1]);
#332  start[0]++;
tst_diskless.c#182    size_t start[1] = {0};
#216    if (nc_put_vara_short(ncidvarid2startcountshort_data)) ERR;
tst_diskless3.c#53   size_t start[ONE_DIM], count[ONE_DIM], index[ONE_DIM], len_in;
#75      start[0] = r;
#79  if((status=nc_put_vara_text(ncidvarid[v], startcount, &data[r]))) ERRSTAT(status);
#109   size_t start[NDIMS], count[NDIMS];
#120   start[0] = 0;
#121   if((status=nc_put_vara_text(ncidvaridstartcount, &data))) ERRSTAT(status);
tst_diskless4.c#46    size_t start[1];
#162 start[0] = i*CHUNKSIZE;
#165 if((status=nc_put_vara(ncid,varids[iv],start,count,(void*)data)))
#173 start[0] = i*CHUNKSIZE;
#175 if((status=nc_get_vara(ncid,varids[iv],start,count,(void*)data)))
tst_files2.c#96   size_t start[MAX_DIMS], count[MAX_DIMS];
#142  start[d] = 0;
#152  for (start[0] = 0; start[0] < (dim_len[0] ? dim_len[0] : num_recs); start[0]++)
#153     for (start[1] = 0; start[1] < dim_len[1]; start[1]++)
#154        if (nc_put_vara_float(ncidvarids[i], startcount,
#159  for (start[0] = 0; start[0] < (dim_len[0] ? dim_len[0] : num_recs); start[0]++)
#160     if (nc_put_vara_float(ncidvarids[i], startcount,
tst_files3.c#31   size_t start[NDIMS] = {0, 0, 0};
#45   for (start[0] = 0; start[0] < X_LENstart[0]++)
#46      for (start[1] = 0; start[1] < Y_LENstart[1]++)
#47  if (nc_put_vara_float(ncidvarstartcountdata)) ERR_RET;
#56   size_t start[NDIMS] = {0, 0, 0}, count[NDIMS] = {X_LENY_LENZ_LEN};
#69   if (nc_put_vars_float(ncidvarstartcountstridedata)) ERR_RET;
#78   size_t start[NDIMS] = {0, 0, 0}, count[NDIMS] = {X_LENY_LENZ_LEN};
#91   if (nc_put_vars_float(ncidvarstartcountstridedata)) ERR_RET;
#103   hsize_t start[NDIMS] = {0, 0, 0};
#139   for (start[0] = 0; start[0] < X_LENstart[0]++)
#140      for (start[1] = 0; start[1] < Y_LENstart[1]++)
#142  if (H5Sselect_hyperslab(file_spaceidH5S_SELECT_SETstartNULL,
tst_files4.c#53       size_t start[4] = {0, 0, 0, 0};
#83       startcountdata)) ERR;
tst_fill_attr_vanish.c#45  size_t start[1] = {0}, count[1] = {1};
#76  if (nc_put_vara(ncidtime_idstartcountdata)) ERR;
tst_fillbug.c#28   size_t start[1] = {0}, count[1] = {1};
#50   if (nc_put_vara(ncidtime_idstartcountdata)) ERR;
tst_fills.c#93      size_t start[2] = {0, 0};
#109      if (nc_put_vara_int(ncidrec_idstartcountrec)) ERR;
#112      if (nc_get_vara_text(ncid, 1, startcountvals)) ERR;
#122      if (nc_get_vara_text(ncid, 1, startcountvals)) ERR;
#265  size_t start[] = {0, 0};
#274        if (nc_get_vara_text(ncidvaridstartcountvals)) ERR;
#282        if (nc_get_vara_schar(ncidvaridstartcountvals)) ERR;
#290        if (nc_get_vara_short(ncidvaridstartcountvals)) ERR;
#298        if (nc_get_vara_int(ncidvaridstartcountvals)) ERR;
#306        if (nc_get_vara_float(ncidvaridstartcountvals)) ERR;
#314        if (nc_get_vara_double(ncidvaridstartcountvals)) ERR;
tst_grps.c#865      size_t start[1] = {0}, count[1] = {3};
#874      if (nc_put_vara_int(henry_vii_idvaridstartcountdata_out)) ERR;
#890      if (nc_get_vara_int(grpids_in[0], 0, startcountdata_in)) ERR;
tst_grps2.c#172      size_t start[1] = {0}, count[1] = {3};
#181      if (nc_put_vara_int(henry_vii_idvaridstartcountdata_out)) ERR;
#197      if (nc_get_vara_int(grpids_in[0], 0, startcountdata_in)) ERR;
tst_h4_lendian.c#61    int32 dims[2], start[2], edges[2], rank;
#65    start[0] = 0;
#66    start[1] = 0;
#95    istat = SDwritedata(sds_idstartNULLedges, (VOIDP)array_data);
tst_h_dimscales2.c#565  hsize_t start[DIMS2] = {0, 0};
#595  startNULLcountNULL) < 0) ERR;
#615  start[0]++;
#617  startNULLcountNULL) < 0) ERR;
tst_h_enums.c#156      hsize_t start[1] = {1}, count[1] = {1};
#199       startNULLcountNULL) < 0) ERR;
tst_h_files.c#176      hsize_t start[NDIMS], count[NDIMS];
#211  start[0] = s * SC;
#213  startNULLcountNULL) < 0) ERR;
#244      hsize_t start[MAX_DIMS],  count[MAX_DIMS];
#340      start[0] = 0;
#341      start[1] = 0;
#344      if (H5Sselect_hyperslab(file_spaceidH5S_SELECT_SETstartNULLcountNULL) < 0) ERR;
tst_h_par.c#68      hsize_t start[NDIMS], count[NDIMS];
#126  start[0] = s * SC1 * p + my_rank * SC1;
#129  startNULLcountNULL) < 0) ERR;
#185  start[0] = s * SC1 * p + my_rank * SC1;
#188  startNULLcountNULL) < 0)
tst_h_strings2.c#32      hsize_t xtend_size[NDIMS] = {2}, start[NDIMS] = {1}, count[NDIMS] = {1};
#94       startNULLcountNULL) < 0) ERR;
#129      hsize_t start[NDIMS] = {1}, count[NDIMS] = {1};
#182       startNULLcountNULL) < 0) ERR;
tst_h_vars.c#68      hsize_t start[MAX_DIMS], count[MAX_DIMS];
#149      start[0] = 1;
#150      start[1] = 0;
#151      start[2] = 0;
#153       startNULLcountNULL) < 0) ERR;
tst_interops2.c#29      int32 start[DIMS_2] = {0, 0}, edge[DIMS_2] = {LAT_LENLON_LEN};
#46      if (SDwritedata(sds_idstartNULLedge, (void *)data_out)) ERR;
tst_knmi.c#90   size_t start[NDIMS3], count[NDIMS3];
tst_large.c#76    size_t start[NUMDIMS], count[NUMDIMS];
#89    start[1] = 0;
#92    for (start[0] = 0; start[0] < DIM1start[0]++) {
#93 if (nc_put_vara_schar(ncidvaridstartcountvals))
tst_large.c#32      size_t start[NUMDIMS] = {0, 0}, count[NUMDIMS] = {1, DIM2};
#48      if (nc_put_vara_schar(ncidvaridstartcountvals)) ERR;
tst_large2.c#34      size_t start[NDIMS] = {0, 0, 0};
#63  for (start[0] = 0; start[0] < TIME_LENstart[0]++)
#68   data[j + LON_LEN * i] = (start[0] + i + j) % 19;
#71     if (nc_put_vara_float(ncidvaridstartcountdata)) ERR;
#78  for (start[0] = 0; start[0] < TIME_LENstart[0]++)
#80     if (nc_get_vara_float(ncidvaridstartcountdata)) ERR;
#84   if (data[j + LON_LEN * i] != (start[0] + i + j) % 19)
#87     start[0], ij, (start[0] + i + j), data[j + LON_LEN * i]);
tst_nc4perf.c#38   size_t start[NDIMS1], count[NDIMS1];
#84      start[0] = 0;
#85      start[1] = mpi_rank * DIMSIZE1/mpi_size;
#97  if (nc_put_vara_float(ncidvarid1[i], startcountdata)) ERR;
tst_nofill2.c#35   size_t start[NDIMS4] = {0, 0, 0, 0};
#69      start[1] = i;
#70      if (nc_put_vara_float(ncidzonal_wnd_idstartcountzonal_wnd)) ERR;
tst_parallel.c#41    size_t start[NDIMS], count[NDIMS];
#121    start[0] = mpi_rank * DIMSIZE/mpi_size;
#122    start[1] = 0;
#132    for (start[2] = 0; start[2] < NUM_SLABSstart[2]++)
#139       if (nc_put_vara_int(ncidv1idstartcountslab_data)) ERR;
tst_parallel2.c#40    size_t start[NDIMS] = {0, 0, 0};
#138       start[0] = NUM_SLABS / mpi_size * mpi_rank + i;
#145       if (nc_put_vara_int(ncidvaridstartcountdata)) ERR;
#179       start[0] = NUM_SLABS / mpi_size * mpi_rank + i;
#186       if (nc_get_vara_int(ncidvaridstartcountdata_in)) ERR;
tst_parallel3.c#189   size_t start[NDIMS1];
#227   start[0] = 0;
#228   start[1] = mpi_rank * DIMSIZE/mpi_size;
#246   if (nc_put_vara_int(ncidnvidstartcountdata)) ERR;
#306   start[0] = 0;
#307   start[1] = mpi_rank * DIMSIZE/mpi_size;
#316   if (nc_get_vara_int(ncidrvidstartcountrdata)) ERR;
#401   size_t start[NDIMS1];
#443   start[0] = 0;
#444   start[1] = mpi_rank * DIMSIZE/mpi_size;
#461   if (nc_put_vara_int(ncidnvidstartcountdata)) ERR;
#471   start[0] = 0;
#472   start[1] = mpi_rank * DIMSIZE/mpi_size;
#579   size_t start[NDIMS1], count[NDIMS1];
#626         start[0] = 0;
#627         start[1] = mpi_rank*count_atom;
#632         start[0] = DIMSIZE2/2;
#633         start[1] = (mpi_rank-mpi_size/2-1)*count_atom;
#642         start[0] = 0;
#643         start[1] = mpi_rank*count_atom;
#648         start[0] = DIMSIZE2/2;
#649         start[1] = (mpi_rank-mpi_size/2)*count_atom;
#666   if (nc_put_vara_int(ncidnvidstartcountdata)) ERR;
#681   if (nc_get_vara_int(ncidrvidstartcountrdata)) ERR;
#712    size_t start[2];
#738    start[0] = rank;
#739    start[1] = 0;
#742    if (nc_put_vara_int(ncFilencVarVrtxstartcountvertices)) ERR;
tst_parallel4.c#44    size_t start[NDIMS] = {0, 0, 0};
#142       start[0] = NUM_SLABS / mpi_size * mpi_rank + i;
#149       if (nc_put_vara_int(ncidvaridstartcountdata)) ERR;
#187       start[0] = NUM_SLABS / mpi_size * mpi_rank + i;
#194       if (nc_get_vara_int(ncidvaridstartcountdata_in)) ERR;
tst_pnetcdf.c#30    size_t start[2], count[2];
#81            start[0] = 0; count[0] = NX;
#82            if (nc_put_vara_int(ncidvarid[i], startcountbuf)) ERR;
#85            start[0] = 0; start[1] = 0;
#87            if (nc_put_vara_int(ncidvarid[i], startcountbuf)) ERR;
#108            start[0] = 0; count[0] = NX;
#115            start[0] = 0; start[1] = 0;
#117            if (nc_get_vara_int(ncidvarid[i], startcountbuf)) ERR;
tst_put_vars.c#26    size_t start[NDIMS] = {0, 0, 0};
#60    if ((retval = nc_put_vars_float(ncidvaridstartcountstridemydata)))
tst_put_vars_two_unlim_dim.c#16    size_t start = 0;
#49    if ((ret = nc_put_vars_double(ncidvar1id, &start, &countNULL, &vals[0])))  {
#55    if ((ret = nc_put_vars_double(ncidvar2id, &start, &countNULL, &vals[0])))  {
tst_rename.c#203              size_t start[] = {0};
#205              if (nc_put_vara(ncidlon_varstartcountlon_data)) ERR;
#209              size_t start[] = {0};
#211              if (nc_put_vara(g1_grpg1_lon_varstartcountg1_lon_data)) ERR;
tst_simplerw_coll_r.c#53    size_t start[NDIMS] = {0, 0, 0};
#150       start[0] = NUM_SLABS / mpi_size * mpi_rank + i;
#157       if (nc_put_vara_int(ncidvaridstartcountdata)) ERR;
#196       start[0] = NUM_SLABS / mpi_size * mpi_rank + i;
#209       if (nc_get_vara_int(ncidvaridstartcountdata_in)) ERR;
tst_small.c#147   size_t istart[NDIMS], count[NDIMS];
#167   start[1] = 0;
#171   for (start[0] = 0; start[0] < NUM_VALSstart[0]++)
#172      if ((stat=nc_put_vara_text(ncidvaridstartcountdata[start[0]]))!=NC_NOERRERR2;
#195   size_t istart[NDIMS], count[NDIMS];
#215   start[1] = 0;
#216   for (start[0] = 0; start[0] < NUM_VALSstart[0]++)
#217      if (nc_put_vara_text(ncidvaridstartcountdata[start[0]])) ERR;
#240   size_t start[NDIMS], count[NDIMS];
#250   start[0] = 0;
#254   if (nc_put_vara_text(ncidvaridstartcount, &data)) ERR;
#278   size_t start[ONE_DIM], count[ONE_DIM], index[ONE_DIM], len_in;
#314  start[0] = r;
#316  if (nc_put_vara_text(ncidvaridstartcount, &data[r])) ERR;
#343   size_t start[ONE_DIM], count[ONE_DIM], index[ONE_DIM], len_in;
#364      start[0] = r;
#368      if (nc_put_vara_text(ncidvaridstartcount, &data[r])) ERR;
#399   size_t start[ONE_DIM], count[ONE_DIM], index[ONE_DIM], len_in;
#430      start[0] = r;
#434  if (nc_put_vara_text(ncidvarid[v], startcount, &data[r])) ERR;
#463   size_t start[NDIMS], count[NDIMS];
#474   start[0] = 0;
#478   if (nc_put_vara_text(ncidvaridstartcount, &data)) ERR;
tst_strings.c#171      size_t start[NDIMS_PRES], count[NDIMS_PRES];
#183      start[0] = 0;
#185      if (nc_put_vara_string(ncidvaridstartcount, (const char **)data)) ERR;
#210      size_t start[NDIMS_PRES], count[NDIMS_PRES];
#224      start[0] = 0;
#227      status = nc_put_vars_string(ncidvaridstartcountstride, (const char **)data);
#234      if (nc_get_vars_string(ncidvaridstartcountstridedata_in)) ERR;
tst_unlim_vars.c#35   size_t start[NDIMS], count[NDIMS];
#119      start[d] = 0;
#123   if (nc_put_vara_float(ncid, 0, startcount, (float *)data_out)) ERR;
#146   if (nc_get_vara_float(ncid, 0, startcount, (float *)data_in)) ERR;
tst_varms.c#36   size_t start[2], count[2];
#73      start[0] = start[1] = 0;
#78      if (nc_get_varm_int(ncidvaridstartcountstridemap,
#88      if (nc_get_varm_int(ncidvaridstartcountstridemap,
#131      start[0] = start[1] = 0;
#137      if (nc_get_varm_int(ncidvaridstartcountstridemap,
#161      size_t start[3] = {0, 0, 0}, count[3] = {D0D1D2};
#192      if (nc_get_varm_float(ncid, 0, startcountstrideimap,
#220      size_t start[2] = {0, 0}, count[2] = {6, 4};
#243      if (nc_put_varm_float(ncid, 0, startcountstrideimap,
#247      if (nc_put_vara_float(ncid, 1, startcount,
tst_vars.c#82   size_t start[NDIMS_EX], count[NDIMS_EX];
#176   start[1] = 0;
#177   start[2] = 0;
#178   start[3] = 0;
#186      start[0] = rec;
#187      if (nc_put_vara_float(ncidpres_varidstartcount,
#189      if (nc_put_vara_float(ncidtemp_varidstartcount,
tst_vars2.c#89         size_t start[NUM_DIMS], count[NUM_DIMS];
#103         start[0] = 1;
#105         if (nc_put_vara_schar(ncidvaridstartcount, &data)) ERR;
#108         start[0] = 0;
#109         if (nc_get_vara_schar(ncidvaridstartcount, &data_in)) ERR;
#114         start[0] = 1;
#115         if (nc_get_vara_schar(ncidvaridstartcount, &data_in)) ERR;
#137         start[0] = 0;
#138         if (nc_get_vara_schar(ncidvaridstartcount, &data_in)) ERR;
#143         start[0] = 1;
#144         if (nc_get_vara_schar(ncidvaridstartcount, &data_in)) ERR;
tst_vars3.c#239      size_t start[1] = {0}, count[1] = {1};
#259      if (nc_put_vara(ncidtime_idstartcountdata)) ERR;
tst_vlen_data.c#138       size_t start[VAR5_RANK], count[VAR5_RANK];
#139       start[0] = 0;
#141       if (nc_get_vara(ncidvaridstartcountvals_in)) ERR;
util.c#591crossproduct(Dimsetdimset, int start, int stop)
#595    for(i=start;i<stop;i++) {
#645findunlimited(Dimsetdimset, int start)
#647    for(;start<dimset->ndims;start++) {
#648 if(dimset->dimsyms[start]->dim.isunlimited)
#649     return start;
util.c#819    size_t start[MAX_RANK];
#829 start[j] = 0;
#842     err = nc_put_vara_text(ncidistartvar_shape[i], text);
#846     err = nc_put_vara_double(ncidistartvar_shape[i], value);
util.h#53extern size_t crossproduct(Dimsetdimset, int start, int stop);
#54extern int findunlimited(Dimsetdimset, int start);


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