constraints.c#417     slice->stride = stridep[dimindex+j];
#420     slice->length = count * slice->stride;
#449    if(slice->first != 0 || slice->stride != 1) return 0;
#678        || slice1->stride != slice2->stride)
#805    size_t stride = slice->stride;
#806    if(first == 0 && stride == 1) return; /* no need to do anything */
#808    slice->stride = 1;
dapdump.c#577    } else if(slice->stride == 1) {
#584                (unsigned long)slice->stride,
dapodom.c#26 odom->stride[i] = segment->slices[i+startindex].stride;
#43     const ptrdiff_tstride, const size_t* size)
#55 istride = (size_t)(stride != NULL ? stride[i] : 1);
#60 odom->stride[i] = istride;
#87 (size_t)odom->stride[i],
#120        odom->index[i] += odom->stride[i];
#138 tmp = tmp / odom->stride[i];
dapodom.h#16    size_t         stride[NC_MAX_VAR_DIMS];
#27 const ptrdiff_tstride, const size_t* size);
dceconstraints.c#77 prefix,s->first,s->stride,last,s->stop,s->length,s->count);
#190#define MAP(s1,i) ((s1)->first + ((s1)->stride*(i)))
#205    sr.stride    = s1->stride * s2->stride;
#214    sr.count = (sr.length + (sr.stride - 1))/sr.stride;
#618            } else if(slice->stride == 1) {
#626     (unsigned long)slice->stride,
#913       || slice->stride != 1
#935    slice->stride = 1;
#972  size_t* stride,
#981     if(stride != NULLstride[i] = (size_t)segment->slices[i].stride;
#1062     (unsigned long)slice->stride,
dceconstraints.h#24    size_t stride;
#126  size_t* stride,
dceparse.c#127    unsigned long first=0,stride=0,last=0;
#137        sscanf((char*)sstride,"%lu",&stride);
#139 stride = 1; /* default */
#141    if(stride == 0)
#146    slice->stride = (stride == 0 ? 1 : stride);
#149    slice->count  = slice->length / slice->stride;
#209    slice->stride = 1;
dv2i.c#787    const long* stride,
#791 if(stride == NULL)
#799 A_DECL(strdpptrdiff_tndimsstride);
#802 A_INIT(strdpptrdiff_tndimsstride);
#825    const long* stride,
#829 if(stride == NULL)
#836 A_DECL(strdpptrdiff_tndimsstride);
#839 A_INIT(strdpptrdiff_tndimsstride);
#862    const long* stride,
#869 return ncvarputs(ncidvaridstartcountstridevalue);
#890 A_DECL(strdpptrdiff_tndimsstride);
#893 A_INIT(strdpptrdiff_tndimsstride);
#919    const long* stride,
#926 return ncvargets(ncidvaridstartcountstridevalue);
#947 A_DECL(strdpptrdiff_tndimsstride);
#950 A_INIT(strdpptrdiff_tndimsstride);
dvarget.c#23    ptrdiff_t      stride[NC_MAX_VAR_DIMS];
#34     const size_t* start, const size_t* edges, const ptrdiff_tstride)
#43 odom->stride[i] = (stride != NULL ? stride[i] : 1);
#44 odom->stop[i] = odom->start[i] + (odom->edges[i]*((size_t)odom->stride[i]));
#67        odom->index[i] += (size_t)odom->stride[i];
#126     const size_t * edges, const ptrdiff_t * stride,
#134   return ncp->dispatch->get_varm(ncid,varid,start,edges,stride,NULL,value0,memtype);
#215 mystride[i] = (stride == NULL ? 1 : stride[i]);
#273     const size_t *edges, const ptrdiff_t *stride,
#347      if(stride != NULL) {
#351            if (stride[idim] == 0
#353                || ((unsigned long) stride[idim] >= X_INT_MAX))
#357     if(stride[idim] != 1) stride1 = 0;
#408  mystride[idim] = stride != NULL
#409     ? stride[idim]
#515     const size_t *edges, const ptrdiff_t *stride, void *value,
#525   return ncp->dispatch->get_vars(ncid,varid,start,edges,stride,value,memtype);
#534     const size_t *edges, const ptrdiff_t *stride, const ptrdiff_tmap,
#544   return ncp->dispatch->get_varm(ncid,varid,start,edges,stride,map,value,memtype);
dvarput.c#17    ptrdiff_t      stride[NC_MAX_VAR_DIMS];
#24     const size_t* start, const size_t* edges, const ptrdiff_tstride)
#33 odom->stride[i] = (stride != NULL ? stride[i] : 1);
#34 odom->stop[i] = odom->start[i] + (odom->edges[i]*(size_t)odom->stride[i]);
#51        odom->index[i] += (size_t)odom->stride[i];
#112     const size_t * edges, const ptrdiff_t * stride,
#120   return ncp->dispatch->put_varm(ncid,varid,start,edges,stride,NULL,value0,memtype);
#213 mystride[i] = (stride == NULL ? 1 : stride[i]);
#276   const ptrdiff_t * stride,
#353      if(stride != NULL) {
#355            if ((stride[idim] == 0)
#357                || ((unsigned long) stride[idim] >= X_INT_MAX))
#361     if(stride[idim] != 1) stride1 = 0;
#406  mystride[idim] = stride != NULL
#407     ? stride[idim]
#496     const size_t *edges, const ptrdiff_t *stride,
#506   return ncp->dispatch->put_vars(ncid,varid,start,edges,stride,value,memtype);
#514     const size_t *edges, const ptrdiff_t *stride, const ptrdiff_tmap,
#524   return ncp->dispatch->put_varm(ncid,varid,start,edges,stride,map,value,memtype);
getvara.c#700        if(odom->start[i] != 0 || odom->stride[i] != 1
#908slice->first,slice->stride,slice->stop,slice->declsize);
#913    for(i=slice->first;i<slice->length;i+=slice->stride) {
#1205     const ptrdiff_tstride,
#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);
ncd2dispatch.c#86     const size_t *start, const size_t *edges, const ptrdiff_tstride,
#90     const size_t *start, const size_t *edges, const ptrdiff_tstride,
#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);
occonstraints.h#11    size_t stride;
ocdump.c#215    if(slice->stride > 1) fprintf(stdout,":%lu",(unsigned long)slice->stride);
test_get.c#3936    ptrdiff_t stride[MAX_RANK];
#3951            stride[j] = 1;
#3953        err = nc_get_vars_text(BAD_IDistartedgestridevalue);
#3956        err = nc_get_vars_text(ncidBAD_VARIDstartedgestridevalue);
#3961            err = nc_get_vars_text(ncidistartedgestridevalue);
#3970            err = nc_get_vars_text(ncidistartedgestridevalue);
#3974            stride[j] = 0;
#3975            err = nc_get_vars_text(ncidistartedgestridevalue);
#3978            stride[j] = 1;
#4000                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#4001                nstarts *= stride[j];
#4009                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#4028 index2[d] = index[d] + index2[d] * stride[d];
#4041                    err = nc_get_vars_text(ncidiindexcountstridevalue);
#4110    ptrdiff_t stride[MAX_RANK];
#4125            stride[j] = 1;
#4127        err = nc_get_vars_uchar(BAD_IDistartedgestridevalue);
#4130        err = nc_get_vars_uchar(ncidBAD_VARIDstartedgestridevalue);
#4135            err = nc_get_vars_uchar(ncidistartedgestridevalue);
#4144            err = nc_get_vars_uchar(ncidistartedgestridevalue);
#4148            stride[j] = 0;
#4149            err = nc_get_vars_uchar(ncidistartedgestridevalue);
#4152            stride[j] = 1;
#4174                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#4175                nstarts *= stride[j];
#4183                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#4202 index2[d] = index[d] + index2[d] * stride[d];
#4215                    err = nc_get_vars_uchar(ncidiindexcountstridevalue);
#4284    ptrdiff_t stride[MAX_RANK];
#4299            stride[j] = 1;
#4301        err = nc_get_vars_schar(BAD_IDistartedgestridevalue);
#4304        err = nc_get_vars_schar(ncidBAD_VARIDstartedgestridevalue);
#4309            err = nc_get_vars_schar(ncidistartedgestridevalue);
#4318            err = nc_get_vars_schar(ncidistartedgestridevalue);
#4322            stride[j] = 0;
#4323            err = nc_get_vars_schar(ncidistartedgestridevalue);
#4326            stride[j] = 1;
#4348                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#4349                nstarts *= stride[j];
#4357                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#4376 index2[d] = index[d] + index2[d] * stride[d];
#4389                    err = nc_get_vars_schar(ncidiindexcountstridevalue);
#4458    ptrdiff_t stride[MAX_RANK];
#4473            stride[j] = 1;
#4475        err = nc_get_vars_short(BAD_IDistartedgestridevalue);
#4478        err = nc_get_vars_short(ncidBAD_VARIDstartedgestridevalue);
#4483            err = nc_get_vars_short(ncidistartedgestridevalue);
#4492            err = nc_get_vars_short(ncidistartedgestridevalue);
#4496            stride[j] = 0;
#4497            err = nc_get_vars_short(ncidistartedgestridevalue);
#4500            stride[j] = 1;
#4522                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#4523                nstarts *= stride[j];
#4531                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#4550 index2[d] = index[d] + index2[d] * stride[d];
#4563                    err = nc_get_vars_short(ncidiindexcountstridevalue);
#4632    ptrdiff_t stride[MAX_RANK];
#4647            stride[j] = 1;
#4649        err = nc_get_vars_int(BAD_IDistartedgestridevalue);
#4652        err = nc_get_vars_int(ncidBAD_VARIDstartedgestridevalue);
#4657            err = nc_get_vars_int(ncidistartedgestridevalue);
#4666            err = nc_get_vars_int(ncidistartedgestridevalue);
#4670            stride[j] = 0;
#4671            err = nc_get_vars_int(ncidistartedgestridevalue);
#4674            stride[j] = 1;
#4696                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#4697                nstarts *= stride[j];
#4705                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#4724 index2[d] = index[d] + index2[d] * stride[d];
#4737                    err = nc_get_vars_int(ncidiindexcountstridevalue);
#4806    ptrdiff_t stride[MAX_RANK];
#4821            stride[j] = 1;
#4823        err = nc_get_vars_long(BAD_IDistartedgestridevalue);
#4826        err = nc_get_vars_long(ncidBAD_VARIDstartedgestridevalue);
#4831            err = nc_get_vars_long(ncidistartedgestridevalue);
#4840            err = nc_get_vars_long(ncidistartedgestridevalue);
#4844            stride[j] = 0;
#4845            err = nc_get_vars_long(ncidistartedgestridevalue);
#4848            stride[j] = 1;
#4870                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#4871                nstarts *= stride[j];
#4879                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#4898 index2[d] = index[d] + index2[d] * stride[d];
#4911                    err = nc_get_vars_long(ncidiindexcountstridevalue);
#4980    ptrdiff_t stride[MAX_RANK];
#4995            stride[j] = 1;
#4997        err = nc_get_vars_float(BAD_IDistartedgestridevalue);
#5000        err = nc_get_vars_float(ncidBAD_VARIDstartedgestridevalue);
#5005            err = nc_get_vars_float(ncidistartedgestridevalue);
#5014            err = nc_get_vars_float(ncidistartedgestridevalue);
#5018            stride[j] = 0;
#5019            err = nc_get_vars_float(ncidistartedgestridevalue);
#5022            stride[j] = 1;
#5044                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#5045                nstarts *= stride[j];
#5053                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#5072 index2[d] = index[d] + index2[d] * stride[d];
#5085                    err = nc_get_vars_float(ncidiindexcountstridevalue);
#5154    ptrdiff_t stride[MAX_RANK];
#5169            stride[j] = 1;
#5171        err = nc_get_vars_double(BAD_IDistartedgestridevalue);
#5174        err = nc_get_vars_double(ncidBAD_VARIDstartedgestridevalue);
#5179            err = nc_get_vars_double(ncidistartedgestridevalue);
#5188            err = nc_get_vars_double(ncidistartedgestridevalue);
#5192            stride[j] = 0;
#5193            err = nc_get_vars_double(ncidistartedgestridevalue);
#5196            stride[j] = 1;
#5218                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#5219                nstarts *= stride[j];
#5227                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#5246 index2[d] = index[d] + index2[d] * stride[d];
#5259                    err = nc_get_vars_double(ncidiindexcountstridevalue);
#5328    ptrdiff_t stride[MAX_RANK];
#5343            stride[j] = 1;
#5345        err = nc_get_vars_ushort(BAD_IDistartedgestridevalue);
#5348        err = nc_get_vars_ushort(ncidBAD_VARIDstartedgestridevalue);
#5353            err = nc_get_vars_ushort(ncidistartedgestridevalue);
#5362            err = nc_get_vars_ushort(ncidistartedgestridevalue);
#5366            stride[j] = 0;
#5367            err = nc_get_vars_ushort(ncidistartedgestridevalue);
#5370            stride[j] = 1;
#5392                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#5393                nstarts *= stride[j];
#5401                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#5420 index2[d] = index[d] + index2[d] * stride[d];
#5433                    err = nc_get_vars_ushort(ncidiindexcountstridevalue);
#5502    ptrdiff_t stride[MAX_RANK];
#5517            stride[j] = 1;
#5519        err = nc_get_vars_uint(BAD_IDistartedgestridevalue);
#5522        err = nc_get_vars_uint(ncidBAD_VARIDstartedgestridevalue);
#5527            err = nc_get_vars_uint(ncidistartedgestridevalue);
#5536            err = nc_get_vars_uint(ncidistartedgestridevalue);
#5540            stride[j] = 0;
#5541            err = nc_get_vars_uint(ncidistartedgestridevalue);
#5544            stride[j] = 1;
#5566                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#5567                nstarts *= stride[j];
#5575                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#5594 index2[d] = index[d] + index2[d] * stride[d];
#5607                    err = nc_get_vars_uint(ncidiindexcountstridevalue);
#5676    ptrdiff_t stride[MAX_RANK];
#5691            stride[j] = 1;
#5693        err = nc_get_vars_longlong(BAD_IDistartedgestridevalue);
#5696        err = nc_get_vars_longlong(ncidBAD_VARIDstartedgestridevalue);
#5701            err = nc_get_vars_longlong(ncidistartedgestridevalue);
#5710            err = nc_get_vars_longlong(ncidistartedgestridevalue);
#5714            stride[j] = 0;
#5715            err = nc_get_vars_longlong(ncidistartedgestridevalue);
#5718            stride[j] = 1;
#5740                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#5741                nstarts *= stride[j];
#5749                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#5768 index2[d] = index[d] + index2[d] * stride[d];
#5781                    err = nc_get_vars_longlong(ncidiindexcountstridevalue);
#5850    ptrdiff_t stride[MAX_RANK];
#5865            stride[j] = 1;
#5867        err = nc_get_vars_ulonglong(BAD_IDistartedgestridevalue);
#5870        err = nc_get_vars_ulonglong(ncidBAD_VARIDstartedgestridevalue);
#5875            err = nc_get_vars_ulonglong(ncidistartedgestridevalue);
#5884            err = nc_get_vars_ulonglong(ncidistartedgestridevalue);
#5888            stride[j] = 0;
#5889            err = nc_get_vars_ulonglong(ncidistartedgestridevalue);
#5892            stride[j] = 1;
#5914                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#5915                nstarts *= stride[j];
#5923                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#5942 index2[d] = index[d] + index2[d] * stride[d];
#5955                    err = nc_get_vars_ulonglong(ncidiindexcountstridevalue);
#6027    ptrdiff_t stride[MAX_RANK];
#6043            stride[j] = 1;
#6046        err = nc_get_varm_text(BAD_IDistartedgestrideimapvalue);
#6049        err = nc_get_varm_text(ncidBAD_VARIDstartedgestrideimapvalue);
#6054            err = nc_get_varm_text(ncidistartedgestrideimapvalue);
#6063            err = nc_get_varm_text(ncidistartedgestrideimapvalue);
#6067            stride[j] = 0;
#6068            err = nc_get_varm_text(ncidistartedgestrideimapvalue);
#6071            stride[j] = 1;
#6093                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#6094                nstarts *= stride[j];
#6102                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#6127                        index2[d] = index[d] + index2[d] * stride[d];
#6140                    err = nc_get_varm_text(ncid,i,index,count,stride,imap,value);
#6209    ptrdiff_t stride[MAX_RANK];
#6225            stride[j] = 1;
#6228        err = nc_get_varm_uchar(BAD_IDistartedgestrideimapvalue);
#6231        err = nc_get_varm_uchar(ncidBAD_VARIDstartedgestrideimapvalue);
#6236            err = nc_get_varm_uchar(ncidistartedgestrideimapvalue);
#6245            err = nc_get_varm_uchar(ncidistartedgestrideimapvalue);
#6249            stride[j] = 0;
#6250            err = nc_get_varm_uchar(ncidistartedgestrideimapvalue);
#6253            stride[j] = 1;
#6275                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#6276                nstarts *= stride[j];
#6284                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#6309                        index2[d] = index[d] + index2[d] * stride[d];
#6322                    err = nc_get_varm_uchar(ncid,i,index,count,stride,imap,value);
#6391    ptrdiff_t stride[MAX_RANK];
#6407            stride[j] = 1;
#6410        err = nc_get_varm_schar(BAD_IDistartedgestrideimapvalue);
#6413        err = nc_get_varm_schar(ncidBAD_VARIDstartedgestrideimapvalue);
#6418            err = nc_get_varm_schar(ncidistartedgestrideimapvalue);
#6427            err = nc_get_varm_schar(ncidistartedgestrideimapvalue);
#6431            stride[j] = 0;
#6432            err = nc_get_varm_schar(ncidistartedgestrideimapvalue);
#6435            stride[j] = 1;
#6457                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#6458                nstarts *= stride[j];
#6466                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#6491                        index2[d] = index[d] + index2[d] * stride[d];
#6504                    err = nc_get_varm_schar(ncid,i,index,count,stride,imap,value);
#6573    ptrdiff_t stride[MAX_RANK];
#6589            stride[j] = 1;
#6592        err = nc_get_varm_short(BAD_IDistartedgestrideimapvalue);
#6595        err = nc_get_varm_short(ncidBAD_VARIDstartedgestrideimapvalue);
#6600            err = nc_get_varm_short(ncidistartedgestrideimapvalue);
#6609            err = nc_get_varm_short(ncidistartedgestrideimapvalue);
#6613            stride[j] = 0;
#6614            err = nc_get_varm_short(ncidistartedgestrideimapvalue);
#6617            stride[j] = 1;
#6639                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#6640                nstarts *= stride[j];
#6648                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#6673                        index2[d] = index[d] + index2[d] * stride[d];
#6686                    err = nc_get_varm_short(ncid,i,index,count,stride,imap,value);
#6755    ptrdiff_t stride[MAX_RANK];
#6771            stride[j] = 1;
#6774        err = nc_get_varm_int(BAD_IDistartedgestrideimapvalue);
#6777        err = nc_get_varm_int(ncidBAD_VARIDstartedgestrideimapvalue);
#6782            err = nc_get_varm_int(ncidistartedgestrideimapvalue);
#6791            err = nc_get_varm_int(ncidistartedgestrideimapvalue);
#6795            stride[j] = 0;
#6796            err = nc_get_varm_int(ncidistartedgestrideimapvalue);
#6799            stride[j] = 1;
#6821                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#6822                nstarts *= stride[j];
#6830                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#6855                        index2[d] = index[d] + index2[d] * stride[d];
#6868                    err = nc_get_varm_int(ncid,i,index,count,stride,imap,value);
#6937    ptrdiff_t stride[MAX_RANK];
#6953            stride[j] = 1;
#6956        err = nc_get_varm_long(BAD_IDistartedgestrideimapvalue);
#6959        err = nc_get_varm_long(ncidBAD_VARIDstartedgestrideimapvalue);
#6964            err = nc_get_varm_long(ncidistartedgestrideimapvalue);
#6973            err = nc_get_varm_long(ncidistartedgestrideimapvalue);
#6977            stride[j] = 0;
#6978            err = nc_get_varm_long(ncidistartedgestrideimapvalue);
#6981            stride[j] = 1;
#7003                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#7004                nstarts *= stride[j];
#7012                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7037                        index2[d] = index[d] + index2[d] * stride[d];
#7050                    err = nc_get_varm_long(ncid,i,index,count,stride,imap,value);
#7119    ptrdiff_t stride[MAX_RANK];
#7135            stride[j] = 1;
#7138        err = nc_get_varm_float(BAD_IDistartedgestrideimapvalue);
#7141        err = nc_get_varm_float(ncidBAD_VARIDstartedgestrideimapvalue);
#7146            err = nc_get_varm_float(ncidistartedgestrideimapvalue);
#7155            err = nc_get_varm_float(ncidistartedgestrideimapvalue);
#7159            stride[j] = 0;
#7160            err = nc_get_varm_float(ncidistartedgestrideimapvalue);
#7163            stride[j] = 1;
#7185                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#7186                nstarts *= stride[j];
#7194                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7219                        index2[d] = index[d] + index2[d] * stride[d];
#7232                    err = nc_get_varm_float(ncid,i,index,count,stride,imap,value);
#7301    ptrdiff_t stride[MAX_RANK];
#7317            stride[j] = 1;
#7320        err = nc_get_varm_double(BAD_IDistartedgestrideimapvalue);
#7323        err = nc_get_varm_double(ncidBAD_VARIDstartedgestrideimapvalue);
#7328            err = nc_get_varm_double(ncidistartedgestrideimapvalue);
#7337            err = nc_get_varm_double(ncidistartedgestrideimapvalue);
#7341            stride[j] = 0;
#7342            err = nc_get_varm_double(ncidistartedgestrideimapvalue);
#7345            stride[j] = 1;
#7367                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#7368                nstarts *= stride[j];
#7376                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7401                        index2[d] = index[d] + index2[d] * stride[d];
#7414                    err = nc_get_varm_double(ncid,i,index,count,stride,imap,value);
#7483    ptrdiff_t stride[MAX_RANK];
#7499            stride[j] = 1;
#7502        err = nc_get_varm_ushort(BAD_IDistartedgestrideimapvalue);
#7505        err = nc_get_varm_ushort(ncidBAD_VARIDstartedgestrideimapvalue);
#7510            err = nc_get_varm_ushort(ncidistartedgestrideimapvalue);
#7519            err = nc_get_varm_ushort(ncidistartedgestrideimapvalue);
#7523            stride[j] = 0;
#7524            err = nc_get_varm_ushort(ncidistartedgestrideimapvalue);
#7527            stride[j] = 1;
#7549                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#7550                nstarts *= stride[j];
#7558                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7583                        index2[d] = index[d] + index2[d] * stride[d];
#7596                    err = nc_get_varm_ushort(ncid,i,index,count,stride,imap,value);
#7665    ptrdiff_t stride[MAX_RANK];
#7681            stride[j] = 1;
#7684        err = nc_get_varm_uint(BAD_IDistartedgestrideimapvalue);
#7687        err = nc_get_varm_uint(ncidBAD_VARIDstartedgestrideimapvalue);
#7692            err = nc_get_varm_uint(ncidistartedgestrideimapvalue);
#7701            err = nc_get_varm_uint(ncidistartedgestrideimapvalue);
#7705            stride[j] = 0;
#7706            err = nc_get_varm_uint(ncidistartedgestrideimapvalue);
#7709            stride[j] = 1;
#7731                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#7732                nstarts *= stride[j];
#7740                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7765                        index2[d] = index[d] + index2[d] * stride[d];
#7778                    err = nc_get_varm_uint(ncid,i,index,count,stride,imap,value);
#7847    ptrdiff_t stride[MAX_RANK];
#7863            stride[j] = 1;
#7866        err = nc_get_varm_longlong(BAD_IDistartedgestrideimapvalue);
#7869        err = nc_get_varm_longlong(ncidBAD_VARIDstartedgestrideimapvalue);
#7874            err = nc_get_varm_longlong(ncidistartedgestrideimapvalue);
#7883            err = nc_get_varm_longlong(ncidistartedgestrideimapvalue);
#7887            stride[j] = 0;
#7888            err = nc_get_varm_longlong(ncidistartedgestrideimapvalue);
#7891            stride[j] = 1;
#7913                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#7914                nstarts *= stride[j];
#7922                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7947                        index2[d] = index[d] + index2[d] * stride[d];
#7960                    err = nc_get_varm_longlong(ncid,i,index,count,stride,imap,value);
#8029    ptrdiff_t stride[MAX_RANK];
#8045            stride[j] = 1;
#8048        err = nc_get_varm_ulonglong(BAD_IDistartedgestrideimapvalue);
#8051        err = nc_get_varm_ulonglong(ncidBAD_VARIDstartedgestrideimapvalue);
#8056            err = nc_get_varm_ulonglong(ncidistartedgestrideimapvalue);
#8065            err = nc_get_varm_ulonglong(ncidistartedgestrideimapvalue);
#8069            stride[j] = 0;
#8070            err = nc_get_varm_ulonglong(ncidistartedgestrideimapvalue);
#8073            stride[j] = 1;
#8095                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#8096                nstarts *= stride[j];
#8104                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#8129                        index2[d] = index[d] + index2[d] * stride[d];
#8142                    err = nc_get_varm_ulonglong(ncid,i,index,count,stride,imap,value);
test_nstride_cached.c#87    ptrdiff_t stride[5];
#116        stride[idim] = 1;
#153    stride[0] = 1;
#154    stride[1] = 1;
#159 idim,start[idim],idim,count[idim],idim,stride[idim]);
#162    ncstatus = nc_get_vars_float (ncidvaridstartcountstride, (float*) dat);
#203    stride[0] = 1;
#204    stride[1] = 1;
#209 idimstart[idim], idimcount[idim], idimstride[idim]);
#212    ncstatus = nc_get_vars_float (ncidvaridstartcountstride, (float*) dat);
#260    stride[0] = 2;
#261    stride[1] = 4;
#266 idim,start[idim],idim,count[idim],idim,stride[idim]);
#270    ncstatus = nc_get_vars_float (ncidvaridstartcountstride,  (float*) sdat);
test_put.c#6750    ptrdiff_t stride[MAX_RANK];
#6787     stride[j] = 1;
#6789 err = nc_put_vars_text(BAD_IDistartedgestridevalue);
#6792 err = nc_put_vars_text(ncidBAD_VARIDstartedgestridevalue);
#6798 err = nc_put_vars_text(ncidistartedgestridevalue);
#6807 err = nc_put_vars_text(ncidistartedgestridevalue);
#6811 stride[j] = 0;
#6812 err = nc_put_vars_text(ncidistartedgestridevalue);
#6815 stride[j] = 1;
#6838 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#6839 nstarts *= stride[j];
#6847     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#6865 index2[d] = index[d] + index2[d] * stride[d];
#6872     err = nc_put_vars_text(ncidiNULLNULLstridevalue);
#6874     err = nc_put_vars_text(ncidiindexcountstridevalue);
#6922    ptrdiff_t stride[MAX_RANK];
#6959     stride[j] = 1;
#6961 err = nc_put_vars_uchar(BAD_IDistartedgestridevalue);
#6964 err = nc_put_vars_uchar(ncidBAD_VARIDstartedgestridevalue);
#6970 err = nc_put_vars_uchar(ncidistartedgestridevalue);
#6979 err = nc_put_vars_uchar(ncidistartedgestridevalue);
#6983 stride[j] = 0;
#6984 err = nc_put_vars_uchar(ncidistartedgestridevalue);
#6987 stride[j] = 1;
#7010 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#7011 nstarts *= stride[j];
#7019     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7037 index2[d] = index[d] + index2[d] * stride[d];
#7044     err = nc_put_vars_uchar(ncidiNULLNULLstridevalue);
#7046     err = nc_put_vars_uchar(ncidiindexcountstridevalue);
#7094    ptrdiff_t stride[MAX_RANK];
#7131     stride[j] = 1;
#7133 err = nc_put_vars_schar(BAD_IDistartedgestridevalue);
#7136 err = nc_put_vars_schar(ncidBAD_VARIDstartedgestridevalue);
#7142 err = nc_put_vars_schar(ncidistartedgestridevalue);
#7151 err = nc_put_vars_schar(ncidistartedgestridevalue);
#7155 stride[j] = 0;
#7156 err = nc_put_vars_schar(ncidistartedgestridevalue);
#7159 stride[j] = 1;
#7182 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#7183 nstarts *= stride[j];
#7191     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7209 index2[d] = index[d] + index2[d] * stride[d];
#7216     err = nc_put_vars_schar(ncidiNULLNULLstridevalue);
#7218     err = nc_put_vars_schar(ncidiindexcountstridevalue);
#7266    ptrdiff_t stride[MAX_RANK];
#7303     stride[j] = 1;
#7305 err = nc_put_vars_short(BAD_IDistartedgestridevalue);
#7308 err = nc_put_vars_short(ncidBAD_VARIDstartedgestridevalue);
#7314 err = nc_put_vars_short(ncidistartedgestridevalue);
#7323 err = nc_put_vars_short(ncidistartedgestridevalue);
#7327 stride[j] = 0;
#7328 err = nc_put_vars_short(ncidistartedgestridevalue);
#7331 stride[j] = 1;
#7354 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#7355 nstarts *= stride[j];
#7363     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7381 index2[d] = index[d] + index2[d] * stride[d];
#7388     err = nc_put_vars_short(ncidiNULLNULLstridevalue);
#7390     err = nc_put_vars_short(ncidiindexcountstridevalue);
#7438    ptrdiff_t stride[MAX_RANK];
#7475     stride[j] = 1;
#7477 err = nc_put_vars_int(BAD_IDistartedgestridevalue);
#7480 err = nc_put_vars_int(ncidBAD_VARIDstartedgestridevalue);
#7486 err = nc_put_vars_int(ncidistartedgestridevalue);
#7495 err = nc_put_vars_int(ncidistartedgestridevalue);
#7499 stride[j] = 0;
#7500 err = nc_put_vars_int(ncidistartedgestridevalue);
#7503 stride[j] = 1;
#7526 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#7527 nstarts *= stride[j];
#7535     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7553 index2[d] = index[d] + index2[d] * stride[d];
#7560     err = nc_put_vars_int(ncidiNULLNULLstridevalue);
#7562     err = nc_put_vars_int(ncidiindexcountstridevalue);
#7610    ptrdiff_t stride[MAX_RANK];
#7647     stride[j] = 1;
#7649 err = nc_put_vars_long(BAD_IDistartedgestridevalue);
#7652 err = nc_put_vars_long(ncidBAD_VARIDstartedgestridevalue);
#7658 err = nc_put_vars_long(ncidistartedgestridevalue);
#7667 err = nc_put_vars_long(ncidistartedgestridevalue);
#7671 stride[j] = 0;
#7672 err = nc_put_vars_long(ncidistartedgestridevalue);
#7675 stride[j] = 1;
#7698 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#7699 nstarts *= stride[j];
#7707     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7725 index2[d] = index[d] + index2[d] * stride[d];
#7732     err = nc_put_vars_long(ncidiNULLNULLstridevalue);
#7734     err = nc_put_vars_long(ncidiindexcountstridevalue);
#7782    ptrdiff_t stride[MAX_RANK];
#7819     stride[j] = 1;
#7821 err = nc_put_vars_float(BAD_IDistartedgestridevalue);
#7824 err = nc_put_vars_float(ncidBAD_VARIDstartedgestridevalue);
#7830 err = nc_put_vars_float(ncidistartedgestridevalue);
#7839 err = nc_put_vars_float(ncidistartedgestridevalue);
#7843 stride[j] = 0;
#7844 err = nc_put_vars_float(ncidistartedgestridevalue);
#7847 stride[j] = 1;
#7870 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#7871 nstarts *= stride[j];
#7879     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7897 index2[d] = index[d] + index2[d] * stride[d];
#7904     err = nc_put_vars_float(ncidiNULLNULLstridevalue);
#7906     err = nc_put_vars_float(ncidiindexcountstridevalue);
#7954    ptrdiff_t stride[MAX_RANK];
#7991     stride[j] = 1;
#7993 err = nc_put_vars_double(BAD_IDistartedgestridevalue);
#7996 err = nc_put_vars_double(ncidBAD_VARIDstartedgestridevalue);
#8002 err = nc_put_vars_double(ncidistartedgestridevalue);
#8011 err = nc_put_vars_double(ncidistartedgestridevalue);
#8015 stride[j] = 0;
#8016 err = nc_put_vars_double(ncidistartedgestridevalue);
#8019 stride[j] = 1;
#8042 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#8043 nstarts *= stride[j];
#8051     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#8069 index2[d] = index[d] + index2[d] * stride[d];
#8076     err = nc_put_vars_double(ncidiNULLNULLstridevalue);
#8078     err = nc_put_vars_double(ncidiindexcountstridevalue);
#8126    ptrdiff_t stride[MAX_RANK];
#8163     stride[j] = 1;
#8165 err = nc_put_vars_ushort(BAD_IDistartedgestridevalue);
#8168 err = nc_put_vars_ushort(ncidBAD_VARIDstartedgestridevalue);
#8174 err = nc_put_vars_ushort(ncidistartedgestridevalue);
#8183 err = nc_put_vars_ushort(ncidistartedgestridevalue);
#8187 stride[j] = 0;
#8188 err = nc_put_vars_ushort(ncidistartedgestridevalue);
#8191 stride[j] = 1;
#8214 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#8215 nstarts *= stride[j];
#8223     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#8241 index2[d] = index[d] + index2[d] * stride[d];
#8248     err = nc_put_vars_ushort(ncidiNULLNULLstridevalue);
#8250     err = nc_put_vars_ushort(ncidiindexcountstridevalue);
#8298    ptrdiff_t stride[MAX_RANK];
#8335     stride[j] = 1;
#8337 err = nc_put_vars_uint(BAD_IDistartedgestridevalue);
#8340 err = nc_put_vars_uint(ncidBAD_VARIDstartedgestridevalue);
#8346 err = nc_put_vars_uint(ncidistartedgestridevalue);
#8355 err = nc_put_vars_uint(ncidistartedgestridevalue);
#8359 stride[j] = 0;
#8360 err = nc_put_vars_uint(ncidistartedgestridevalue);
#8363 stride[j] = 1;
#8386 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#8387 nstarts *= stride[j];
#8395     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#8413 index2[d] = index[d] + index2[d] * stride[d];
#8420     err = nc_put_vars_uint(ncidiNULLNULLstridevalue);
#8422     err = nc_put_vars_uint(ncidiindexcountstridevalue);
#8470    ptrdiff_t stride[MAX_RANK];
#8507     stride[j] = 1;
#8509 err = nc_put_vars_longlong(BAD_IDistartedgestridevalue);
#8512 err = nc_put_vars_longlong(ncidBAD_VARIDstartedgestridevalue);
#8518 err = nc_put_vars_longlong(ncidistartedgestridevalue);
#8527 err = nc_put_vars_longlong(ncidistartedgestridevalue);
#8531 stride[j] = 0;
#8532 err = nc_put_vars_longlong(ncidistartedgestridevalue);
#8535 stride[j] = 1;
#8558 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#8559 nstarts *= stride[j];
#8567     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#8585 index2[d] = index[d] + index2[d] * stride[d];
#8592     err = nc_put_vars_longlong(ncidiNULLNULLstridevalue);
#8594     err = nc_put_vars_longlong(ncidiindexcountstridevalue);
#8642    ptrdiff_t stride[MAX_RANK];
#8679     stride[j] = 1;
#8681 err = nc_put_vars_ulonglong(BAD_IDistartedgestridevalue);
#8684 err = nc_put_vars_ulonglong(ncidBAD_VARIDstartedgestridevalue);
#8690 err = nc_put_vars_ulonglong(ncidistartedgestridevalue);
#8699 err = nc_put_vars_ulonglong(ncidistartedgestridevalue);
#8703 stride[j] = 0;
#8704 err = nc_put_vars_ulonglong(ncidistartedgestridevalue);
#8707 stride[j] = 1;
#8730 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#8731 nstarts *= stride[j];
#8739     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#8757 index2[d] = index[d] + index2[d] * stride[d];
#8764     err = nc_put_vars_ulonglong(ncidiNULLNULLstridevalue);
#8766     err = nc_put_vars_ulonglong(ncidiindexcountstridevalue);
#8817    ptrdiff_t stride[MAX_RANK];
#8855     stride[j] = 1;
#8858 err = nc_put_varm_text(BAD_IDistartedgestrideimapvalue);
#8861 err = nc_put_varm_text(ncidBAD_VARIDstartedgestrideimapvalue);
#8867 err = nc_put_varm_text(ncidistartedgestrideimapvalue);
#8876 err = nc_put_varm_text(ncidistartedgestrideimapvalue);
#8880 stride[j] = 0;
#8881 err = nc_put_varm_text(ncidistartedgestrideimapvalue);
#8884 stride[j] = 1;
#8907 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#8908 nstarts *= stride[j];
#8916                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#8940                        index2[d] = index[d] + index2[d] * stride[d];
#8949                    err = nc_put_varm_text(ncid,i,index,count,stride,imap,value);
#8997    ptrdiff_t stride[MAX_RANK];
#9035     stride[j] = 1;
#9038 err = nc_put_varm_uchar(BAD_IDistartedgestrideimapvalue);
#9041 err = nc_put_varm_uchar(ncidBAD_VARIDstartedgestrideimapvalue);
#9047 err = nc_put_varm_uchar(ncidistartedgestrideimapvalue);
#9056 err = nc_put_varm_uchar(ncidistartedgestrideimapvalue);
#9060 stride[j] = 0;
#9061 err = nc_put_varm_uchar(ncidistartedgestrideimapvalue);
#9064 stride[j] = 1;
#9087 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#9088 nstarts *= stride[j];
#9096                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#9120                        index2[d] = index[d] + index2[d] * stride[d];
#9129                    err = nc_put_varm_uchar(ncid,i,index,count,stride,imap,value);
#9177    ptrdiff_t stride[MAX_RANK];
#9215     stride[j] = 1;
#9218 err = nc_put_varm_schar(BAD_IDistartedgestrideimapvalue);
#9221 err = nc_put_varm_schar(ncidBAD_VARIDstartedgestrideimapvalue);
#9227 err = nc_put_varm_schar(ncidistartedgestrideimapvalue);
#9236 err = nc_put_varm_schar(ncidistartedgestrideimapvalue);
#9240 stride[j] = 0;
#9241 err = nc_put_varm_schar(ncidistartedgestrideimapvalue);
#9244 stride[j] = 1;
#9267 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#9268 nstarts *= stride[j];
#9276                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#9300                        index2[d] = index[d] + index2[d] * stride[d];
#9309                    err = nc_put_varm_schar(ncid,i,index,count,stride,imap,value);
#9357    ptrdiff_t stride[MAX_RANK];
#9395     stride[j] = 1;
#9398 err = nc_put_varm_short(BAD_IDistartedgestrideimapvalue);
#9401 err = nc_put_varm_short(ncidBAD_VARIDstartedgestrideimapvalue);
#9407 err = nc_put_varm_short(ncidistartedgestrideimapvalue);
#9416 err = nc_put_varm_short(ncidistartedgestrideimapvalue);
#9420 stride[j] = 0;
#9421 err = nc_put_varm_short(ncidistartedgestrideimapvalue);
#9424 stride[j] = 1;
#9447 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#9448 nstarts *= stride[j];
#9456                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#9480                        index2[d] = index[d] + index2[d] * stride[d];
#9489                    err = nc_put_varm_short(ncid,i,index,count,stride,imap,value);
#9537    ptrdiff_t stride[MAX_RANK];
#9575     stride[j] = 1;
#9578 err = nc_put_varm_int(BAD_IDistartedgestrideimapvalue);
#9581 err = nc_put_varm_int(ncidBAD_VARIDstartedgestrideimapvalue);
#9587 err = nc_put_varm_int(ncidistartedgestrideimapvalue);
#9596 err = nc_put_varm_int(ncidistartedgestrideimapvalue);
#9600 stride[j] = 0;
#9601 err = nc_put_varm_int(ncidistartedgestrideimapvalue);
#9604 stride[j] = 1;
#9627 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#9628 nstarts *= stride[j];
#9636                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#9660                        index2[d] = index[d] + index2[d] * stride[d];
#9669                    err = nc_put_varm_int(ncid,i,index,count,stride,imap,value);
#9717    ptrdiff_t stride[MAX_RANK];
#9755     stride[j] = 1;
#9758 err = nc_put_varm_long(BAD_IDistartedgestrideimapvalue);
#9761 err = nc_put_varm_long(ncidBAD_VARIDstartedgestrideimapvalue);
#9767 err = nc_put_varm_long(ncidistartedgestrideimapvalue);
#9776 err = nc_put_varm_long(ncidistartedgestrideimapvalue);
#9780 stride[j] = 0;
#9781 err = nc_put_varm_long(ncidistartedgestrideimapvalue);
#9784 stride[j] = 1;
#9807 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#9808 nstarts *= stride[j];
#9816                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#9840                        index2[d] = index[d] + index2[d] * stride[d];
#9849                    err = nc_put_varm_long(ncid,i,index,count,stride,imap,value);
#9897    ptrdiff_t stride[MAX_RANK];
#9935     stride[j] = 1;
#9938 err = nc_put_varm_float(BAD_IDistartedgestrideimapvalue);
#9941 err = nc_put_varm_float(ncidBAD_VARIDstartedgestrideimapvalue);
#9947 err = nc_put_varm_float(ncidistartedgestrideimapvalue);
#9956 err = nc_put_varm_float(ncidistartedgestrideimapvalue);
#9960 stride[j] = 0;
#9961 err = nc_put_varm_float(ncidistartedgestrideimapvalue);
#9964 stride[j] = 1;
#9987 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#9988 nstarts *= stride[j];
#9996                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#10020                        index2[d] = index[d] + index2[d] * stride[d];
#10029                    err = nc_put_varm_float(ncid,i,index,count,stride,imap,value);
#10077    ptrdiff_t stride[MAX_RANK];
#10115     stride[j] = 1;
#10118 err = nc_put_varm_double(BAD_IDistartedgestrideimapvalue);
#10121 err = nc_put_varm_double(ncidBAD_VARIDstartedgestrideimapvalue);
#10127 err = nc_put_varm_double(ncidistartedgestrideimapvalue);
#10136 err = nc_put_varm_double(ncidistartedgestrideimapvalue);
#10140 stride[j] = 0;
#10141 err = nc_put_varm_double(ncidistartedgestrideimapvalue);
#10144 stride[j] = 1;
#10167 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#10168 nstarts *= stride[j];
#10176                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#10200                        index2[d] = index[d] + index2[d] * stride[d];
#10209                    err = nc_put_varm_double(ncid,i,index,count,stride,imap,value);
#10257    ptrdiff_t stride[MAX_RANK];
#10295     stride[j] = 1;
#10298 err = nc_put_varm_ushort(BAD_IDistartedgestrideimapvalue);
#10301 err = nc_put_varm_ushort(ncidBAD_VARIDstartedgestrideimapvalue);
#10307 err = nc_put_varm_ushort(ncidistartedgestrideimapvalue);
#10316 err = nc_put_varm_ushort(ncidistartedgestrideimapvalue);
#10320 stride[j] = 0;
#10321 err = nc_put_varm_ushort(ncidistartedgestrideimapvalue);
#10324 stride[j] = 1;
#10347 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#10348 nstarts *= stride[j];
#10356                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#10380                        index2[d] = index[d] + index2[d] * stride[d];
#10389                    err = nc_put_varm_ushort(ncid,i,index,count,stride,imap,value);
#10437    ptrdiff_t stride[MAX_RANK];
#10475     stride[j] = 1;
#10478 err = nc_put_varm_uint(BAD_IDistartedgestrideimapvalue);
#10481 err = nc_put_varm_uint(ncidBAD_VARIDstartedgestrideimapvalue);
#10487 err = nc_put_varm_uint(ncidistartedgestrideimapvalue);
#10496 err = nc_put_varm_uint(ncidistartedgestrideimapvalue);
#10500 stride[j] = 0;
#10501 err = nc_put_varm_uint(ncidistartedgestrideimapvalue);
#10504 stride[j] = 1;
#10527 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#10528 nstarts *= stride[j];
#10536                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#10560                        index2[d] = index[d] + index2[d] * stride[d];
#10569                    err = nc_put_varm_uint(ncid,i,index,count,stride,imap,value);
#10617    ptrdiff_t stride[MAX_RANK];
#10655     stride[j] = 1;
#10658 err = nc_put_varm_longlong(BAD_IDistartedgestrideimapvalue);
#10661 err = nc_put_varm_longlong(ncidBAD_VARIDstartedgestrideimapvalue);
#10667 err = nc_put_varm_longlong(ncidistartedgestrideimapvalue);
#10676 err = nc_put_varm_longlong(ncidistartedgestrideimapvalue);
#10680 stride[j] = 0;
#10681 err = nc_put_varm_longlong(ncidistartedgestrideimapvalue);
#10684 stride[j] = 1;
#10707 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#10708 nstarts *= stride[j];
#10716                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#10740                        index2[d] = index[d] + index2[d] * stride[d];
#10749                    err = nc_put_varm_longlong(ncid,i,index,count,stride,imap,value);
#10797    ptrdiff_t stride[MAX_RANK];
#10835     stride[j] = 1;
#10838 err = nc_put_varm_ulonglong(BAD_IDistartedgestrideimapvalue);
#10841 err = nc_put_varm_ulonglong(ncidBAD_VARIDstartedgestrideimapvalue);
#10847 err = nc_put_varm_ulonglong(ncidistartedgestrideimapvalue);
#10856 err = nc_put_varm_ulonglong(ncidistartedgestrideimapvalue);
#10860 stride[j] = 0;
#10861 err = nc_put_varm_ulonglong(ncidistartedgestrideimapvalue);
#10864 stride[j] = 1;
#10887 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#10888 nstarts *= stride[j];
#10896                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#10920                        index2[d] = index[d] + index2[d] * stride[d];
#10929                    err = nc_put_varm_ulonglong(ncid,i,index,count,stride,imap,value);
test_read.c#1042    ptrdiff_t stride[MAX_RANK];
#1057            stride[j] = 1;
#1059        err = nc_get_vars(BAD_IDistartedgestridebuf);
#1062        err = nc_get_vars(ncidBAD_VARIDstartedgestridebuf);
#1067     err = nc_get_vars(ncidistartedgestridebuf);
#1072     err = nc_get_vars(ncidistartedgestridebuf);
#1076     stride[j] = 0;
#1077     err = nc_get_vars(ncidistartedgestridebuf);
#1080     stride[j] = 1;
#1102 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#1103                nstarts *= stride[j];
#1111     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#1127     err = nc_get_vars(ncidiindexcountstridebuf);
#1141     index2[d] = index[d] + index2[d] * stride[d];
#1207    ptrdiff_t stride[MAX_RANK];
#1224            stride[j] = 1;
#1233        err = nc_get_varm(BAD_IDistartedgestrideimapbuf);
#1236        err = nc_get_varm(ncidBAD_VARIDstartedgestrideimapbuf);
#1241     err = nc_get_varm(ncidistartedgestrideimapbuf);
#1246     err = nc_get_varm(ncidistartedgestrideimapbuf);
#1250     stride[j] = 0;
#1251     err = nc_get_varm(ncidistartedgestrideimapbuf);
#1254     stride[j] = 1;
#1275 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#1277                nstarts *= stride[j];
#1287 count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#1301     err = nc_get_varm(ncidiindexcountstrideimap2p);
test_varm3.c#79    ptrdiff_t stride[5], imap[5];
#118        stride[idim] = 1;
#138    for(i=0;i<ndim;i++) printf(" %d",(int)stride[i]);
#144    err = nc_get_vars_float (ncidvaridstartcountstride,
#151    check(err = nc_get_varm_float (ncidvaridstartcountstrideimap,(float*) dat),__FILE__,__LINE__);
#175    stride[0] = 2;
#185    for(i=0;i<ndim;i++) printf(" %d",(int)stride[i]);
#191    check(err = nc_get_vars_float(ncidvaridstartcountstride,
#197    check(err = nc_get_varm_float(ncidvaridstartcountstrideimap,
#220    stride[0] = 5;
#230    for(i=0;i<ndim;i++) printf(" %d",(int)stride[i]);
#236    check(err = nc_get_vars_float(ncidvaridstartcountstride,
#242    check(err = nc_get_varm_float(ncidvaridstartcountstrideimap,
test_write.c#927    ptrdiff_t stride[MAX_RANK];
#949            stride[j] = 1;
#951        err = nc_put_vars(BAD_IDistartedgestridebuf);
#954        err = nc_put_vars(ncidBAD_VARIDstartedgestridebuf);
#960 err = nc_put_vars(ncidistartedgestridebuf);
#965 err = nc_put_vars(ncidistartedgestridebuf);
#969 stride[j] = 0;
#970 err = nc_put_vars(ncidistartedgestridebuf);
#973 stride[j] = 1;
#995                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#996                nstarts *= stride[j];
#1004                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#1023 index2[d] = index[d] + index2[d] * stride[d];
#1035     err = nc_put_vars(ncidiindexcountstridebuf);
#1080    ptrdiff_t stride[MAX_RANK];
#1104            stride[j] = 1;
#1126        err = nc_put_varm(BAD_IDistartedgestrideimapbuf);
#1129        err = nc_put_varm(ncidBAD_VARIDstartedgestrideimapbuf);
#1135 err = nc_put_varm(ncidistartedgestrideimapbuf);
#1140 err = nc_put_varm(ncidistartedgestrideimapbuf);
#1144 stride[j] = 0;
#1145 err = nc_put_varm(ncidistartedgestrideimapbuf);
#1148 stride[j] = 1;
#1170                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#1172                nstarts *= stride[j];
#1182 count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#1196     err = nc_put_varm(ncidiindexcountstrideimap2p);
tst_compounds.c#190 ptrdiff_t stride[RANK] = {2};
#197        if (nc_put_vars(ncidvaridstartedgesstridedatas)) ERR;
#205        if (nc_get_vars(ncidvaridstartedgesstridedata)) ERR;
tst_files3.c#57   ptrdiff_t stride[NDIMS] = {1, 1, 1};
#69   if (nc_put_vars_float(ncidvarstartcountstridedata)) ERR_RET;
#79   ptrdiff_t stride[NDIMS] = {1, 1, 1};
#91   if (nc_put_vars_float(ncidvarstartcountstridedata)) ERR_RET;
tst_put_vars.c#28    ptrdiff_t stride[NDIMS] = {1, 1, 1};
#60    if ((retval = nc_put_vars_float(ncidvaridstartcountstridemydata)))
tst_strings.c#211      ptrdiff_t stride[NDIMS_PRES];
#226      stride[0] = 2;
#227      status = nc_put_vars_string(ncidvaridstartcountstride, (const char **)data);
#234      if (nc_get_vars_string(ncidvaridstartcountstridedata_in)) ERR;
tst_varms.c#37   ptrdiff_t stride[2], map[2];
#75      stride[0] = stride[1] = 1;
#78      if (nc_get_varm_int(ncidvaridstartcountstridemap,
#88      if (nc_get_varm_int(ncidvaridstartcountstridemap,
#134      stride[0] = stride[1] = 1;
#137      if (nc_get_varm_int(ncidvaridstartcountstridemap,
#160      ptrdiff_t imap[3] = {6, 2, 1}, stride[3] = {1, 1, 1};
#192      if (nc_get_varm_float(ncid, 0, startcountstrideimap,
#219      ptrdiff_t imap[2] = {1, 6}, stride[2] = {1, 1};
#243      if (nc_put_varm_float(ncid, 0, startcountstrideimap,


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