slabs.c#124    long corner[NDIMS], edge[NDIMS], point[NDIMS];
#202     edge[idim] = dims[idim].size;
#206 if (ncvarput(cdfidvarid[iv], corneredge, (void *) v) == -1) {
#211 add_data(&testvarid[iv], corneredge); /* keep test in sync */
#220     edge[idim] = 1;
#223 if (ncvarget(cdfidvarid[iv], corneredge, (void *) v) == -1) {
#237 edge[jdim] = 1;
#241     edge[idim] = dims[idim].size - 2;
#242     if (ncvarget(cdfidvarid[iv], corneredge, (void *) v) == -1) {
#246     for (ii=(int)corner[idim]; ii <= edge[idim]; ii++) {
#261     edge[kdim] = 1;
#266 edge[idim] = dims[idim].size - 2;
#267 edge[jdim] = dims[jdim].size - 2;
#268 if (ncvarget(cdfidvarid[iv], corneredge, (void *) v) == -1) {
#272 for (ii=(int)corner[idim]; ii <= edge[idim]; ii++) {
#273     for (jj=(int)corner[jdim]; jj <= edge[jdim]; jj++) {
#278      (ii-1)*(int)edge[jdim]+jj-1, VF(point))) {
#298 edge[ldim] = 1;
#304     edge[idim] = dims[idim].size - 2;
#305     edge[jdim] = dims[jdim].size - 2;
#306     edge[kdim] = dims[kdim].size - 2;
#307     if (ncvarget(cdfidvarid[iv], corneredge, (void *) v) == -1) {
#311     for (ii=(int)corner[idim]; ii <= edge[idim]; ii++) {
#312 for (jj=(int)corner[jdim]; jj <= edge[jdim]; jj++) {
#313     for (kk=(int)corner[kdim]; kk <= edge[kdim]; kk++) {
#320      ((ii-1)*(int)edge[jdim]+jj-1)*
#321      (int)edge[kdim]+kk-1,VF(point))) {
test_get.c#2053    size_t edge[MAX_RANK];
#2069     edge[j] = 1;
#2071        err = nc_get_vara_text(BAD_IDistartedgevalue);
#2074        err = nc_get_vara_text(ncidBAD_VARIDstartedgevalue);
#2079     err = nc_get_vara_text(ncidistartedgevalue);
#2083     edge[j] = var_shape[i][j] + 1;
#2084     err = nc_get_vara_text(ncidistartedgevalue);
#2087     edge[j] = 1;
#2093 edge[j] = 0;
#2095     err = nc_get_vara_text(BAD_IDistartedgevalue);
#2098     err = nc_get_vara_text(ncidBAD_VARIDstartedgevalue);
#2101     err = nc_get_vara_text(ncidistartedgevalue);
#2110 edge[j] = 1;
#2125                    edge[j] = mid[j];
#2128                    edge[j] = var_shape[i][j] - mid[j];
#2130                nels *= edge[j];
#2134                err = toMixedBase(jvar_rank[i], edgeindex);
#2150 err = nc_get_vara_text(ncidistartedgevalue);
#2209    size_t edge[MAX_RANK];
#2225     edge[j] = 1;
#2227        err = nc_get_vara_uchar(BAD_IDistartedgevalue);
#2230        err = nc_get_vara_uchar(ncidBAD_VARIDstartedgevalue);
#2235     err = nc_get_vara_uchar(ncidistartedgevalue);
#2239     edge[j] = var_shape[i][j] + 1;
#2240     err = nc_get_vara_uchar(ncidistartedgevalue);
#2243     edge[j] = 1;
#2249 edge[j] = 0;
#2251     err = nc_get_vara_uchar(BAD_IDistartedgevalue);
#2254     err = nc_get_vara_uchar(ncidBAD_VARIDstartedgevalue);
#2257     err = nc_get_vara_uchar(ncidistartedgevalue);
#2266 edge[j] = 1;
#2281                    edge[j] = mid[j];
#2284                    edge[j] = var_shape[i][j] - mid[j];
#2286                nels *= edge[j];
#2290                err = toMixedBase(jvar_rank[i], edgeindex);
#2306 err = nc_get_vara_uchar(ncidistartedgevalue);
#2365    size_t edge[MAX_RANK];
#2381     edge[j] = 1;
#2383        err = nc_get_vara_schar(BAD_IDistartedgevalue);
#2386        err = nc_get_vara_schar(ncidBAD_VARIDstartedgevalue);
#2391     err = nc_get_vara_schar(ncidistartedgevalue);
#2395     edge[j] = var_shape[i][j] + 1;
#2396     err = nc_get_vara_schar(ncidistartedgevalue);
#2399     edge[j] = 1;
#2405 edge[j] = 0;
#2407     err = nc_get_vara_schar(BAD_IDistartedgevalue);
#2410     err = nc_get_vara_schar(ncidBAD_VARIDstartedgevalue);
#2413     err = nc_get_vara_schar(ncidistartedgevalue);
#2422 edge[j] = 1;
#2437                    edge[j] = mid[j];
#2440                    edge[j] = var_shape[i][j] - mid[j];
#2442                nels *= edge[j];
#2446                err = toMixedBase(jvar_rank[i], edgeindex);
#2462 err = nc_get_vara_schar(ncidistartedgevalue);
#2521    size_t edge[MAX_RANK];
#2537     edge[j] = 1;
#2539        err = nc_get_vara_short(BAD_IDistartedgevalue);
#2542        err = nc_get_vara_short(ncidBAD_VARIDstartedgevalue);
#2547     err = nc_get_vara_short(ncidistartedgevalue);
#2551     edge[j] = var_shape[i][j] + 1;
#2552     err = nc_get_vara_short(ncidistartedgevalue);
#2555     edge[j] = 1;
#2561 edge[j] = 0;
#2563     err = nc_get_vara_short(BAD_IDistartedgevalue);
#2566     err = nc_get_vara_short(ncidBAD_VARIDstartedgevalue);
#2569     err = nc_get_vara_short(ncidistartedgevalue);
#2578 edge[j] = 1;
#2593                    edge[j] = mid[j];
#2596                    edge[j] = var_shape[i][j] - mid[j];
#2598                nels *= edge[j];
#2602                err = toMixedBase(jvar_rank[i], edgeindex);
#2618 err = nc_get_vara_short(ncidistartedgevalue);
#2677    size_t edge[MAX_RANK];
#2693     edge[j] = 1;
#2695        err = nc_get_vara_int(BAD_IDistartedgevalue);
#2698        err = nc_get_vara_int(ncidBAD_VARIDstartedgevalue);
#2703     err = nc_get_vara_int(ncidistartedgevalue);
#2707     edge[j] = var_shape[i][j] + 1;
#2708     err = nc_get_vara_int(ncidistartedgevalue);
#2711     edge[j] = 1;
#2717 edge[j] = 0;
#2719     err = nc_get_vara_int(BAD_IDistartedgevalue);
#2722     err = nc_get_vara_int(ncidBAD_VARIDstartedgevalue);
#2725     err = nc_get_vara_int(ncidistartedgevalue);
#2734 edge[j] = 1;
#2749                    edge[j] = mid[j];
#2752                    edge[j] = var_shape[i][j] - mid[j];
#2754                nels *= edge[j];
#2758                err = toMixedBase(jvar_rank[i], edgeindex);
#2774 err = nc_get_vara_int(ncidistartedgevalue);
#2833    size_t edge[MAX_RANK];
#2849     edge[j] = 1;
#2851        err = nc_get_vara_long(BAD_IDistartedgevalue);
#2854        err = nc_get_vara_long(ncidBAD_VARIDstartedgevalue);
#2859     err = nc_get_vara_long(ncidistartedgevalue);
#2863     edge[j] = var_shape[i][j] + 1;
#2864     err = nc_get_vara_long(ncidistartedgevalue);
#2867     edge[j] = 1;
#2873 edge[j] = 0;
#2875     err = nc_get_vara_long(BAD_IDistartedgevalue);
#2878     err = nc_get_vara_long(ncidBAD_VARIDstartedgevalue);
#2881     err = nc_get_vara_long(ncidistartedgevalue);
#2890 edge[j] = 1;
#2905                    edge[j] = mid[j];
#2908                    edge[j] = var_shape[i][j] - mid[j];
#2910                nels *= edge[j];
#2914                err = toMixedBase(jvar_rank[i], edgeindex);
#2930 err = nc_get_vara_long(ncidistartedgevalue);
#2989    size_t edge[MAX_RANK];
#3005     edge[j] = 1;
#3007        err = nc_get_vara_float(BAD_IDistartedgevalue);
#3010        err = nc_get_vara_float(ncidBAD_VARIDstartedgevalue);
#3015     err = nc_get_vara_float(ncidistartedgevalue);
#3019     edge[j] = var_shape[i][j] + 1;
#3020     err = nc_get_vara_float(ncidistartedgevalue);
#3023     edge[j] = 1;
#3029 edge[j] = 0;
#3031     err = nc_get_vara_float(BAD_IDistartedgevalue);
#3034     err = nc_get_vara_float(ncidBAD_VARIDstartedgevalue);
#3037     err = nc_get_vara_float(ncidistartedgevalue);
#3046 edge[j] = 1;
#3061                    edge[j] = mid[j];
#3064                    edge[j] = var_shape[i][j] - mid[j];
#3066                nels *= edge[j];
#3070                err = toMixedBase(jvar_rank[i], edgeindex);
#3086 err = nc_get_vara_float(ncidistartedgevalue);
#3145    size_t edge[MAX_RANK];
#3161     edge[j] = 1;
#3163        err = nc_get_vara_double(BAD_IDistartedgevalue);
#3166        err = nc_get_vara_double(ncidBAD_VARIDstartedgevalue);
#3171     err = nc_get_vara_double(ncidistartedgevalue);
#3175     edge[j] = var_shape[i][j] + 1;
#3176     err = nc_get_vara_double(ncidistartedgevalue);
#3179     edge[j] = 1;
#3185 edge[j] = 0;
#3187     err = nc_get_vara_double(BAD_IDistartedgevalue);
#3190     err = nc_get_vara_double(ncidBAD_VARIDstartedgevalue);
#3193     err = nc_get_vara_double(ncidistartedgevalue);
#3202 edge[j] = 1;
#3217                    edge[j] = mid[j];
#3220                    edge[j] = var_shape[i][j] - mid[j];
#3222                nels *= edge[j];
#3226                err = toMixedBase(jvar_rank[i], edgeindex);
#3242 err = nc_get_vara_double(ncidistartedgevalue);
#3301    size_t edge[MAX_RANK];
#3317     edge[j] = 1;
#3319        err = nc_get_vara_ushort(BAD_IDistartedgevalue);
#3322        err = nc_get_vara_ushort(ncidBAD_VARIDstartedgevalue);
#3327     err = nc_get_vara_ushort(ncidistartedgevalue);
#3331     edge[j] = var_shape[i][j] + 1;
#3332     err = nc_get_vara_ushort(ncidistartedgevalue);
#3335     edge[j] = 1;
#3341 edge[j] = 0;
#3343     err = nc_get_vara_ushort(BAD_IDistartedgevalue);
#3346     err = nc_get_vara_ushort(ncidBAD_VARIDstartedgevalue);
#3349     err = nc_get_vara_ushort(ncidistartedgevalue);
#3358 edge[j] = 1;
#3373                    edge[j] = mid[j];
#3376                    edge[j] = var_shape[i][j] - mid[j];
#3378                nels *= edge[j];
#3382                err = toMixedBase(jvar_rank[i], edgeindex);
#3398 err = nc_get_vara_ushort(ncidistartedgevalue);
#3457    size_t edge[MAX_RANK];
#3473     edge[j] = 1;
#3475        err = nc_get_vara_uint(BAD_IDistartedgevalue);
#3478        err = nc_get_vara_uint(ncidBAD_VARIDstartedgevalue);
#3483     err = nc_get_vara_uint(ncidistartedgevalue);
#3487     edge[j] = var_shape[i][j] + 1;
#3488     err = nc_get_vara_uint(ncidistartedgevalue);
#3491     edge[j] = 1;
#3497 edge[j] = 0;
#3499     err = nc_get_vara_uint(BAD_IDistartedgevalue);
#3502     err = nc_get_vara_uint(ncidBAD_VARIDstartedgevalue);
#3505     err = nc_get_vara_uint(ncidistartedgevalue);
#3514 edge[j] = 1;
#3529                    edge[j] = mid[j];
#3532                    edge[j] = var_shape[i][j] - mid[j];
#3534                nels *= edge[j];
#3538                err = toMixedBase(jvar_rank[i], edgeindex);
#3554 err = nc_get_vara_uint(ncidistartedgevalue);
#3613    size_t edge[MAX_RANK];
#3629     edge[j] = 1;
#3631        err = nc_get_vara_longlong(BAD_IDistartedgevalue);
#3634        err = nc_get_vara_longlong(ncidBAD_VARIDstartedgevalue);
#3639     err = nc_get_vara_longlong(ncidistartedgevalue);
#3643     edge[j] = var_shape[i][j] + 1;
#3644     err = nc_get_vara_longlong(ncidistartedgevalue);
#3647     edge[j] = 1;
#3653 edge[j] = 0;
#3655     err = nc_get_vara_longlong(BAD_IDistartedgevalue);
#3658     err = nc_get_vara_longlong(ncidBAD_VARIDstartedgevalue);
#3661     err = nc_get_vara_longlong(ncidistartedgevalue);
#3670 edge[j] = 1;
#3685                    edge[j] = mid[j];
#3688                    edge[j] = var_shape[i][j] - mid[j];
#3690                nels *= edge[j];
#3694                err = toMixedBase(jvar_rank[i], edgeindex);
#3710 err = nc_get_vara_longlong(ncidistartedgevalue);
#3769    size_t edge[MAX_RANK];
#3785     edge[j] = 1;
#3787        err = nc_get_vara_ulonglong(BAD_IDistartedgevalue);
#3790        err = nc_get_vara_ulonglong(ncidBAD_VARIDstartedgevalue);
#3795     err = nc_get_vara_ulonglong(ncidistartedgevalue);
#3799     edge[j] = var_shape[i][j] + 1;
#3800     err = nc_get_vara_ulonglong(ncidistartedgevalue);
#3803     edge[j] = 1;
#3809 edge[j] = 0;
#3811     err = nc_get_vara_ulonglong(BAD_IDistartedgevalue);
#3814     err = nc_get_vara_ulonglong(ncidBAD_VARIDstartedgevalue);
#3817     err = nc_get_vara_ulonglong(ncidistartedgevalue);
#3826 edge[j] = 1;
#3841                    edge[j] = mid[j];
#3844                    edge[j] = var_shape[i][j] - mid[j];
#3846                nels *= edge[j];
#3850                err = toMixedBase(jvar_rank[i], edgeindex);
#3866 err = nc_get_vara_ulonglong(ncidistartedgevalue);
#3930    size_t edge[MAX_RANK];
#3950            edge[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);
#3969            edge[j] = var_shape[i][j] + 1;
#3970            err = nc_get_vars_text(ncidistartedgestridevalue);
#3973            edge[j] = 1;
#3975            err = nc_get_vars_text(ncidistartedgestridevalue);
#3995                    edge[j] = mid[j];
#3998                    edge[j] = var_shape[i][j] - mid[j];
#4000                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#4009                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#4104    size_t edge[MAX_RANK];
#4124            edge[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);
#4143            edge[j] = var_shape[i][j] + 1;
#4144            err = nc_get_vars_uchar(ncidistartedgestridevalue);
#4147            edge[j] = 1;
#4149            err = nc_get_vars_uchar(ncidistartedgestridevalue);
#4169                    edge[j] = mid[j];
#4172                    edge[j] = var_shape[i][j] - mid[j];
#4174                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#4183                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#4278    size_t edge[MAX_RANK];
#4298            edge[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);
#4317            edge[j] = var_shape[i][j] + 1;
#4318            err = nc_get_vars_schar(ncidistartedgestridevalue);
#4321            edge[j] = 1;
#4323            err = nc_get_vars_schar(ncidistartedgestridevalue);
#4343                    edge[j] = mid[j];
#4346                    edge[j] = var_shape[i][j] - mid[j];
#4348                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#4357                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#4452    size_t edge[MAX_RANK];
#4472            edge[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);
#4491            edge[j] = var_shape[i][j] + 1;
#4492            err = nc_get_vars_short(ncidistartedgestridevalue);
#4495            edge[j] = 1;
#4497            err = nc_get_vars_short(ncidistartedgestridevalue);
#4517                    edge[j] = mid[j];
#4520                    edge[j] = var_shape[i][j] - mid[j];
#4522                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#4531                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#4626    size_t edge[MAX_RANK];
#4646            edge[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);
#4665            edge[j] = var_shape[i][j] + 1;
#4666            err = nc_get_vars_int(ncidistartedgestridevalue);
#4669            edge[j] = 1;
#4671            err = nc_get_vars_int(ncidistartedgestridevalue);
#4691                    edge[j] = mid[j];
#4694                    edge[j] = var_shape[i][j] - mid[j];
#4696                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#4705                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#4800    size_t edge[MAX_RANK];
#4820            edge[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);
#4839            edge[j] = var_shape[i][j] + 1;
#4840            err = nc_get_vars_long(ncidistartedgestridevalue);
#4843            edge[j] = 1;
#4845            err = nc_get_vars_long(ncidistartedgestridevalue);
#4865                    edge[j] = mid[j];
#4868                    edge[j] = var_shape[i][j] - mid[j];
#4870                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#4879                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#4974    size_t edge[MAX_RANK];
#4994            edge[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);
#5013            edge[j] = var_shape[i][j] + 1;
#5014            err = nc_get_vars_float(ncidistartedgestridevalue);
#5017            edge[j] = 1;
#5019            err = nc_get_vars_float(ncidistartedgestridevalue);
#5039                    edge[j] = mid[j];
#5042                    edge[j] = var_shape[i][j] - mid[j];
#5044                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#5053                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#5148    size_t edge[MAX_RANK];
#5168            edge[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);
#5187            edge[j] = var_shape[i][j] + 1;
#5188            err = nc_get_vars_double(ncidistartedgestridevalue);
#5191            edge[j] = 1;
#5193            err = nc_get_vars_double(ncidistartedgestridevalue);
#5213                    edge[j] = mid[j];
#5216                    edge[j] = var_shape[i][j] - mid[j];
#5218                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#5227                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#5322    size_t edge[MAX_RANK];
#5342            edge[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);
#5361            edge[j] = var_shape[i][j] + 1;
#5362            err = nc_get_vars_ushort(ncidistartedgestridevalue);
#5365            edge[j] = 1;
#5367            err = nc_get_vars_ushort(ncidistartedgestridevalue);
#5387                    edge[j] = mid[j];
#5390                    edge[j] = var_shape[i][j] - mid[j];
#5392                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#5401                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#5496    size_t edge[MAX_RANK];
#5516            edge[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);
#5535            edge[j] = var_shape[i][j] + 1;
#5536            err = nc_get_vars_uint(ncidistartedgestridevalue);
#5539            edge[j] = 1;
#5541            err = nc_get_vars_uint(ncidistartedgestridevalue);
#5561                    edge[j] = mid[j];
#5564                    edge[j] = var_shape[i][j] - mid[j];
#5566                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#5575                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#5670    size_t edge[MAX_RANK];
#5690            edge[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);
#5709            edge[j] = var_shape[i][j] + 1;
#5710            err = nc_get_vars_longlong(ncidistartedgestridevalue);
#5713            edge[j] = 1;
#5715            err = nc_get_vars_longlong(ncidistartedgestridevalue);
#5735                    edge[j] = mid[j];
#5738                    edge[j] = var_shape[i][j] - mid[j];
#5740                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#5749                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#5844    size_t edge[MAX_RANK];
#5864            edge[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);
#5883            edge[j] = var_shape[i][j] + 1;
#5884            err = nc_get_vars_ulonglong(ncidistartedgestridevalue);
#5887            edge[j] = 1;
#5889            err = nc_get_vars_ulonglong(ncidistartedgestridevalue);
#5909                    edge[j] = mid[j];
#5912                    edge[j] = var_shape[i][j] - mid[j];
#5914                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#5923                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#6021    size_t edge[MAX_RANK];
#6042            edge[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);
#6062            edge[j] = var_shape[i][j] + 1;
#6063            err = nc_get_varm_text(ncidistartedgestrideimapvalue);
#6066            edge[j] = 1;
#6068            err = nc_get_varm_text(ncidistartedgestrideimapvalue);
#6088                    edge[j] = mid[j];
#6091                    edge[j] = var_shape[i][j] - mid[j];
#6093                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#6102                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#6203    size_t edge[MAX_RANK];
#6224            edge[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);
#6244            edge[j] = var_shape[i][j] + 1;
#6245            err = nc_get_varm_uchar(ncidistartedgestrideimapvalue);
#6248            edge[j] = 1;
#6250            err = nc_get_varm_uchar(ncidistartedgestrideimapvalue);
#6270                    edge[j] = mid[j];
#6273                    edge[j] = var_shape[i][j] - mid[j];
#6275                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#6284                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#6385    size_t edge[MAX_RANK];
#6406            edge[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);
#6426            edge[j] = var_shape[i][j] + 1;
#6427            err = nc_get_varm_schar(ncidistartedgestrideimapvalue);
#6430            edge[j] = 1;
#6432            err = nc_get_varm_schar(ncidistartedgestrideimapvalue);
#6452                    edge[j] = mid[j];
#6455                    edge[j] = var_shape[i][j] - mid[j];
#6457                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#6466                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#6567    size_t edge[MAX_RANK];
#6588            edge[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);
#6608            edge[j] = var_shape[i][j] + 1;
#6609            err = nc_get_varm_short(ncidistartedgestrideimapvalue);
#6612            edge[j] = 1;
#6614            err = nc_get_varm_short(ncidistartedgestrideimapvalue);
#6634                    edge[j] = mid[j];
#6637                    edge[j] = var_shape[i][j] - mid[j];
#6639                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#6648                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#6749    size_t edge[MAX_RANK];
#6770            edge[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);
#6790            edge[j] = var_shape[i][j] + 1;
#6791            err = nc_get_varm_int(ncidistartedgestrideimapvalue);
#6794            edge[j] = 1;
#6796            err = nc_get_varm_int(ncidistartedgestrideimapvalue);
#6816                    edge[j] = mid[j];
#6819                    edge[j] = var_shape[i][j] - mid[j];
#6821                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#6830                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#6931    size_t edge[MAX_RANK];
#6952            edge[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);
#6972            edge[j] = var_shape[i][j] + 1;
#6973            err = nc_get_varm_long(ncidistartedgestrideimapvalue);
#6976            edge[j] = 1;
#6978            err = nc_get_varm_long(ncidistartedgestrideimapvalue);
#6998                    edge[j] = mid[j];
#7001                    edge[j] = var_shape[i][j] - mid[j];
#7003                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#7012                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7113    size_t edge[MAX_RANK];
#7134            edge[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);
#7154            edge[j] = var_shape[i][j] + 1;
#7155            err = nc_get_varm_float(ncidistartedgestrideimapvalue);
#7158            edge[j] = 1;
#7160            err = nc_get_varm_float(ncidistartedgestrideimapvalue);
#7180                    edge[j] = mid[j];
#7183                    edge[j] = var_shape[i][j] - mid[j];
#7185                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#7194                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7295    size_t edge[MAX_RANK];
#7316            edge[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);
#7336            edge[j] = var_shape[i][j] + 1;
#7337            err = nc_get_varm_double(ncidistartedgestrideimapvalue);
#7340            edge[j] = 1;
#7342            err = nc_get_varm_double(ncidistartedgestrideimapvalue);
#7362                    edge[j] = mid[j];
#7365                    edge[j] = var_shape[i][j] - mid[j];
#7367                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#7376                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7477    size_t edge[MAX_RANK];
#7498            edge[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);
#7518            edge[j] = var_shape[i][j] + 1;
#7519            err = nc_get_varm_ushort(ncidistartedgestrideimapvalue);
#7522            edge[j] = 1;
#7524            err = nc_get_varm_ushort(ncidistartedgestrideimapvalue);
#7544                    edge[j] = mid[j];
#7547                    edge[j] = var_shape[i][j] - mid[j];
#7549                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#7558                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7659    size_t edge[MAX_RANK];
#7680            edge[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);
#7700            edge[j] = var_shape[i][j] + 1;
#7701            err = nc_get_varm_uint(ncidistartedgestrideimapvalue);
#7704            edge[j] = 1;
#7706            err = nc_get_varm_uint(ncidistartedgestrideimapvalue);
#7726                    edge[j] = mid[j];
#7729                    edge[j] = var_shape[i][j] - mid[j];
#7731                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#7740                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7841    size_t edge[MAX_RANK];
#7862            edge[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);
#7882            edge[j] = var_shape[i][j] + 1;
#7883            err = nc_get_varm_longlong(ncidistartedgestrideimapvalue);
#7886            edge[j] = 1;
#7888            err = nc_get_varm_longlong(ncidistartedgestrideimapvalue);
#7908                    edge[j] = mid[j];
#7911                    edge[j] = var_shape[i][j] - mid[j];
#7913                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#7922                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#8023    size_t edge[MAX_RANK];
#8044            edge[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);
#8064            edge[j] = var_shape[i][j] + 1;
#8065            err = nc_get_varm_ulonglong(ncidistartedgestrideimapvalue);
#8068            edge[j] = 1;
#8070            err = nc_get_varm_ulonglong(ncidistartedgestrideimapvalue);
#8090                    edge[j] = mid[j];
#8093                    edge[j] = var_shape[i][j] - mid[j];
#8095                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#8104                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
test_put.c#4927    size_t edge[MAX_RANK];
#4966            edge[j] = 1;
#4968        err = nc_put_vara_text(BAD_IDistartedgevalue);
#4971        err = nc_put_vara_text(ncidBAD_VARIDstartedgevalue);
#4977 err = nc_put_vara_text(ncidistartedgevalue);
#4981 edge[j] = var_shape[i][j] + 1;
#4982 err = nc_put_vara_text(ncidistartedgevalue);
#4985 edge[j] = 1;
#5003            edge[j] = 1;
#5019     edge[j] = mid[j];
#5022     edge[j] = var_shape[i][j] - mid[j];
#5024 nels *= edge[j];
#5027 err = toMixedBase(jvar_rank[i], edgeindex);
#5039 err = nc_put_vara_text(ncidistartedgevalue);
#5078    size_t edge[MAX_RANK];
#5117            edge[j] = 1;
#5119        err = nc_put_vara_uchar(BAD_IDistartedgevalue);
#5122        err = nc_put_vara_uchar(ncidBAD_VARIDstartedgevalue);
#5128 err = nc_put_vara_uchar(ncidistartedgevalue);
#5132 edge[j] = var_shape[i][j] + 1;
#5133 err = nc_put_vara_uchar(ncidistartedgevalue);
#5136 edge[j] = 1;
#5154            edge[j] = 1;
#5170     edge[j] = mid[j];
#5173     edge[j] = var_shape[i][j] - mid[j];
#5175 nels *= edge[j];
#5178 err = toMixedBase(jvar_rank[i], edgeindex);
#5190 err = nc_put_vara_uchar(ncidistartedgevalue);
#5229    size_t edge[MAX_RANK];
#5268            edge[j] = 1;
#5270        err = nc_put_vara_schar(BAD_IDistartedgevalue);
#5273        err = nc_put_vara_schar(ncidBAD_VARIDstartedgevalue);
#5279 err = nc_put_vara_schar(ncidistartedgevalue);
#5283 edge[j] = var_shape[i][j] + 1;
#5284 err = nc_put_vara_schar(ncidistartedgevalue);
#5287 edge[j] = 1;
#5305            edge[j] = 1;
#5321     edge[j] = mid[j];
#5324     edge[j] = var_shape[i][j] - mid[j];
#5326 nels *= edge[j];
#5329 err = toMixedBase(jvar_rank[i], edgeindex);
#5341 err = nc_put_vara_schar(ncidistartedgevalue);
#5380    size_t edge[MAX_RANK];
#5419            edge[j] = 1;
#5421        err = nc_put_vara_short(BAD_IDistartedgevalue);
#5424        err = nc_put_vara_short(ncidBAD_VARIDstartedgevalue);
#5430 err = nc_put_vara_short(ncidistartedgevalue);
#5434 edge[j] = var_shape[i][j] + 1;
#5435 err = nc_put_vara_short(ncidistartedgevalue);
#5438 edge[j] = 1;
#5456            edge[j] = 1;
#5472     edge[j] = mid[j];
#5475     edge[j] = var_shape[i][j] - mid[j];
#5477 nels *= edge[j];
#5480 err = toMixedBase(jvar_rank[i], edgeindex);
#5492 err = nc_put_vara_short(ncidistartedgevalue);
#5531    size_t edge[MAX_RANK];
#5570            edge[j] = 1;
#5572        err = nc_put_vara_int(BAD_IDistartedgevalue);
#5575        err = nc_put_vara_int(ncidBAD_VARIDstartedgevalue);
#5581 err = nc_put_vara_int(ncidistartedgevalue);
#5585 edge[j] = var_shape[i][j] + 1;
#5586 err = nc_put_vara_int(ncidistartedgevalue);
#5589 edge[j] = 1;
#5607            edge[j] = 1;
#5623     edge[j] = mid[j];
#5626     edge[j] = var_shape[i][j] - mid[j];
#5628 nels *= edge[j];
#5631 err = toMixedBase(jvar_rank[i], edgeindex);
#5643 err = nc_put_vara_int(ncidistartedgevalue);
#5682    size_t edge[MAX_RANK];
#5721            edge[j] = 1;
#5723        err = nc_put_vara_long(BAD_IDistartedgevalue);
#5726        err = nc_put_vara_long(ncidBAD_VARIDstartedgevalue);
#5732 err = nc_put_vara_long(ncidistartedgevalue);
#5736 edge[j] = var_shape[i][j] + 1;
#5737 err = nc_put_vara_long(ncidistartedgevalue);
#5740 edge[j] = 1;
#5758            edge[j] = 1;
#5774     edge[j] = mid[j];
#5777     edge[j] = var_shape[i][j] - mid[j];
#5779 nels *= edge[j];
#5782 err = toMixedBase(jvar_rank[i], edgeindex);
#5794 err = nc_put_vara_long(ncidistartedgevalue);
#5833    size_t edge[MAX_RANK];
#5872            edge[j] = 1;
#5874        err = nc_put_vara_float(BAD_IDistartedgevalue);
#5877        err = nc_put_vara_float(ncidBAD_VARIDstartedgevalue);
#5883 err = nc_put_vara_float(ncidistartedgevalue);
#5887 edge[j] = var_shape[i][j] + 1;
#5888 err = nc_put_vara_float(ncidistartedgevalue);
#5891 edge[j] = 1;
#5909            edge[j] = 1;
#5925     edge[j] = mid[j];
#5928     edge[j] = var_shape[i][j] - mid[j];
#5930 nels *= edge[j];
#5933 err = toMixedBase(jvar_rank[i], edgeindex);
#5945 err = nc_put_vara_float(ncidistartedgevalue);
#5984    size_t edge[MAX_RANK];
#6023            edge[j] = 1;
#6025        err = nc_put_vara_double(BAD_IDistartedgevalue);
#6028        err = nc_put_vara_double(ncidBAD_VARIDstartedgevalue);
#6034 err = nc_put_vara_double(ncidistartedgevalue);
#6038 edge[j] = var_shape[i][j] + 1;
#6039 err = nc_put_vara_double(ncidistartedgevalue);
#6042 edge[j] = 1;
#6060            edge[j] = 1;
#6076     edge[j] = mid[j];
#6079     edge[j] = var_shape[i][j] - mid[j];
#6081 nels *= edge[j];
#6084 err = toMixedBase(jvar_rank[i], edgeindex);
#6096 err = nc_put_vara_double(ncidistartedgevalue);
#6135    size_t edge[MAX_RANK];
#6174            edge[j] = 1;
#6176        err = nc_put_vara_ushort(BAD_IDistartedgevalue);
#6179        err = nc_put_vara_ushort(ncidBAD_VARIDstartedgevalue);
#6185 err = nc_put_vara_ushort(ncidistartedgevalue);
#6189 edge[j] = var_shape[i][j] + 1;
#6190 err = nc_put_vara_ushort(ncidistartedgevalue);
#6193 edge[j] = 1;
#6211            edge[j] = 1;
#6227     edge[j] = mid[j];
#6230     edge[j] = var_shape[i][j] - mid[j];
#6232 nels *= edge[j];
#6235 err = toMixedBase(jvar_rank[i], edgeindex);
#6247 err = nc_put_vara_ushort(ncidistartedgevalue);
#6286    size_t edge[MAX_RANK];
#6325            edge[j] = 1;
#6327        err = nc_put_vara_uint(BAD_IDistartedgevalue);
#6330        err = nc_put_vara_uint(ncidBAD_VARIDstartedgevalue);
#6336 err = nc_put_vara_uint(ncidistartedgevalue);
#6340 edge[j] = var_shape[i][j] + 1;
#6341 err = nc_put_vara_uint(ncidistartedgevalue);
#6344 edge[j] = 1;
#6362            edge[j] = 1;
#6378     edge[j] = mid[j];
#6381     edge[j] = var_shape[i][j] - mid[j];
#6383 nels *= edge[j];
#6386 err = toMixedBase(jvar_rank[i], edgeindex);
#6398 err = nc_put_vara_uint(ncidistartedgevalue);
#6437    size_t edge[MAX_RANK];
#6476            edge[j] = 1;
#6478        err = nc_put_vara_longlong(BAD_IDistartedgevalue);
#6481        err = nc_put_vara_longlong(ncidBAD_VARIDstartedgevalue);
#6487 err = nc_put_vara_longlong(ncidistartedgevalue);
#6491 edge[j] = var_shape[i][j] + 1;
#6492 err = nc_put_vara_longlong(ncidistartedgevalue);
#6495 edge[j] = 1;
#6513            edge[j] = 1;
#6529     edge[j] = mid[j];
#6532     edge[j] = var_shape[i][j] - mid[j];
#6534 nels *= edge[j];
#6537 err = toMixedBase(jvar_rank[i], edgeindex);
#6549 err = nc_put_vara_longlong(ncidistartedgevalue);
#6588    size_t edge[MAX_RANK];
#6627            edge[j] = 1;
#6629        err = nc_put_vara_ulonglong(BAD_IDistartedgevalue);
#6632        err = nc_put_vara_ulonglong(ncidBAD_VARIDstartedgevalue);
#6638 err = nc_put_vara_ulonglong(ncidistartedgevalue);
#6642 edge[j] = var_shape[i][j] + 1;
#6643 err = nc_put_vara_ulonglong(ncidistartedgevalue);
#6646 edge[j] = 1;
#6664            edge[j] = 1;
#6680     edge[j] = mid[j];
#6683     edge[j] = var_shape[i][j] - mid[j];
#6685 nels *= edge[j];
#6688 err = toMixedBase(jvar_rank[i], edgeindex);
#6700 err = nc_put_vara_ulonglong(ncidistartedgevalue);
#6744    size_t edge[MAX_RANK];
#6786     edge[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);
#6806 edge[j] = var_shape[i][j] + 1;
#6807 err = nc_put_vars_text(ncidistartedgestridevalue);
#6810 edge[j] = 1;
#6812 err = nc_put_vars_text(ncidistartedgestridevalue);
#6833     edge[j] = mid[j];
#6836     edge[j] = var_shape[i][j] - mid[j];
#6838 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#6847     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#6916    size_t edge[MAX_RANK];
#6958     edge[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);
#6978 edge[j] = var_shape[i][j] + 1;
#6979 err = nc_put_vars_uchar(ncidistartedgestridevalue);
#6982 edge[j] = 1;
#6984 err = nc_put_vars_uchar(ncidistartedgestridevalue);
#7005     edge[j] = mid[j];
#7008     edge[j] = var_shape[i][j] - mid[j];
#7010 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#7019     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7088    size_t edge[MAX_RANK];
#7130     edge[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);
#7150 edge[j] = var_shape[i][j] + 1;
#7151 err = nc_put_vars_schar(ncidistartedgestridevalue);
#7154 edge[j] = 1;
#7156 err = nc_put_vars_schar(ncidistartedgestridevalue);
#7177     edge[j] = mid[j];
#7180     edge[j] = var_shape[i][j] - mid[j];
#7182 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#7191     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7260    size_t edge[MAX_RANK];
#7302     edge[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);
#7322 edge[j] = var_shape[i][j] + 1;
#7323 err = nc_put_vars_short(ncidistartedgestridevalue);
#7326 edge[j] = 1;
#7328 err = nc_put_vars_short(ncidistartedgestridevalue);
#7349     edge[j] = mid[j];
#7352     edge[j] = var_shape[i][j] - mid[j];
#7354 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#7363     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7432    size_t edge[MAX_RANK];
#7474     edge[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);
#7494 edge[j] = var_shape[i][j] + 1;
#7495 err = nc_put_vars_int(ncidistartedgestridevalue);
#7498 edge[j] = 1;
#7500 err = nc_put_vars_int(ncidistartedgestridevalue);
#7521     edge[j] = mid[j];
#7524     edge[j] = var_shape[i][j] - mid[j];
#7526 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#7535     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7604    size_t edge[MAX_RANK];
#7646     edge[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);
#7666 edge[j] = var_shape[i][j] + 1;
#7667 err = nc_put_vars_long(ncidistartedgestridevalue);
#7670 edge[j] = 1;
#7672 err = nc_put_vars_long(ncidistartedgestridevalue);
#7693     edge[j] = mid[j];
#7696     edge[j] = var_shape[i][j] - mid[j];
#7698 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#7707     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7776    size_t edge[MAX_RANK];
#7818     edge[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);
#7838 edge[j] = var_shape[i][j] + 1;
#7839 err = nc_put_vars_float(ncidistartedgestridevalue);
#7842 edge[j] = 1;
#7844 err = nc_put_vars_float(ncidistartedgestridevalue);
#7865     edge[j] = mid[j];
#7868     edge[j] = var_shape[i][j] - mid[j];
#7870 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#7879     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7948    size_t edge[MAX_RANK];
#7990     edge[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);
#8010 edge[j] = var_shape[i][j] + 1;
#8011 err = nc_put_vars_double(ncidistartedgestridevalue);
#8014 edge[j] = 1;
#8016 err = nc_put_vars_double(ncidistartedgestridevalue);
#8037     edge[j] = mid[j];
#8040     edge[j] = var_shape[i][j] - mid[j];
#8042 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#8051     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#8120    size_t edge[MAX_RANK];
#8162     edge[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);
#8182 edge[j] = var_shape[i][j] + 1;
#8183 err = nc_put_vars_ushort(ncidistartedgestridevalue);
#8186 edge[j] = 1;
#8188 err = nc_put_vars_ushort(ncidistartedgestridevalue);
#8209     edge[j] = mid[j];
#8212     edge[j] = var_shape[i][j] - mid[j];
#8214 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#8223     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#8292    size_t edge[MAX_RANK];
#8334     edge[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);
#8354 edge[j] = var_shape[i][j] + 1;
#8355 err = nc_put_vars_uint(ncidistartedgestridevalue);
#8358 edge[j] = 1;
#8360 err = nc_put_vars_uint(ncidistartedgestridevalue);
#8381     edge[j] = mid[j];
#8384     edge[j] = var_shape[i][j] - mid[j];
#8386 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#8395     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#8464    size_t edge[MAX_RANK];
#8506     edge[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);
#8526 edge[j] = var_shape[i][j] + 1;
#8527 err = nc_put_vars_longlong(ncidistartedgestridevalue);
#8530 edge[j] = 1;
#8532 err = nc_put_vars_longlong(ncidistartedgestridevalue);
#8553     edge[j] = mid[j];
#8556     edge[j] = var_shape[i][j] - mid[j];
#8558 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#8567     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#8636    size_t edge[MAX_RANK];
#8678     edge[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);
#8698 edge[j] = var_shape[i][j] + 1;
#8699 err = nc_put_vars_ulonglong(ncidistartedgestridevalue);
#8702 edge[j] = 1;
#8704 err = nc_put_vars_ulonglong(ncidistartedgestridevalue);
#8725     edge[j] = mid[j];
#8728     edge[j] = var_shape[i][j] - mid[j];
#8730 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#8739     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#8811    size_t edge[MAX_RANK];
#8854     edge[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);
#8875 edge[j] = var_shape[i][j] + 1;
#8876 err = nc_put_varm_text(ncidistartedgestrideimapvalue);
#8879 edge[j] = 1;
#8881 err = nc_put_varm_text(ncidistartedgestrideimapvalue);
#8902     edge[j] = mid[j];
#8905     edge[j] = var_shape[i][j] - mid[j];
#8907 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#8916                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#8991    size_t edge[MAX_RANK];
#9034     edge[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);
#9055 edge[j] = var_shape[i][j] + 1;
#9056 err = nc_put_varm_uchar(ncidistartedgestrideimapvalue);
#9059 edge[j] = 1;
#9061 err = nc_put_varm_uchar(ncidistartedgestrideimapvalue);
#9082     edge[j] = mid[j];
#9085     edge[j] = var_shape[i][j] - mid[j];
#9087 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#9096                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#9171    size_t edge[MAX_RANK];
#9214     edge[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);
#9235 edge[j] = var_shape[i][j] + 1;
#9236 err = nc_put_varm_schar(ncidistartedgestrideimapvalue);
#9239 edge[j] = 1;
#9241 err = nc_put_varm_schar(ncidistartedgestrideimapvalue);
#9262     edge[j] = mid[j];
#9265     edge[j] = var_shape[i][j] - mid[j];
#9267 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#9276                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#9351    size_t edge[MAX_RANK];
#9394     edge[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);
#9415 edge[j] = var_shape[i][j] + 1;
#9416 err = nc_put_varm_short(ncidistartedgestrideimapvalue);
#9419 edge[j] = 1;
#9421 err = nc_put_varm_short(ncidistartedgestrideimapvalue);
#9442     edge[j] = mid[j];
#9445     edge[j] = var_shape[i][j] - mid[j];
#9447 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#9456                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#9531    size_t edge[MAX_RANK];
#9574     edge[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);
#9595 edge[j] = var_shape[i][j] + 1;
#9596 err = nc_put_varm_int(ncidistartedgestrideimapvalue);
#9599 edge[j] = 1;
#9601 err = nc_put_varm_int(ncidistartedgestrideimapvalue);
#9622     edge[j] = mid[j];
#9625     edge[j] = var_shape[i][j] - mid[j];
#9627 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#9636                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#9711    size_t edge[MAX_RANK];
#9754     edge[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);
#9775 edge[j] = var_shape[i][j] + 1;
#9776 err = nc_put_varm_long(ncidistartedgestrideimapvalue);
#9779 edge[j] = 1;
#9781 err = nc_put_varm_long(ncidistartedgestrideimapvalue);
#9802     edge[j] = mid[j];
#9805     edge[j] = var_shape[i][j] - mid[j];
#9807 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#9816                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#9891    size_t edge[MAX_RANK];
#9934     edge[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);
#9955 edge[j] = var_shape[i][j] + 1;
#9956 err = nc_put_varm_float(ncidistartedgestrideimapvalue);
#9959 edge[j] = 1;
#9961 err = nc_put_varm_float(ncidistartedgestrideimapvalue);
#9982     edge[j] = mid[j];
#9985     edge[j] = var_shape[i][j] - mid[j];
#9987 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#9996                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#10071    size_t edge[MAX_RANK];
#10114     edge[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);
#10135 edge[j] = var_shape[i][j] + 1;
#10136 err = nc_put_varm_double(ncidistartedgestrideimapvalue);
#10139 edge[j] = 1;
#10141 err = nc_put_varm_double(ncidistartedgestrideimapvalue);
#10162     edge[j] = mid[j];
#10165     edge[j] = var_shape[i][j] - mid[j];
#10167 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#10176                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#10251    size_t edge[MAX_RANK];
#10294     edge[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);
#10315 edge[j] = var_shape[i][j] + 1;
#10316 err = nc_put_varm_ushort(ncidistartedgestrideimapvalue);
#10319 edge[j] = 1;
#10321 err = nc_put_varm_ushort(ncidistartedgestrideimapvalue);
#10342     edge[j] = mid[j];
#10345     edge[j] = var_shape[i][j] - mid[j];
#10347 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#10356                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#10431    size_t edge[MAX_RANK];
#10474     edge[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);
#10495 edge[j] = var_shape[i][j] + 1;
#10496 err = nc_put_varm_uint(ncidistartedgestrideimapvalue);
#10499 edge[j] = 1;
#10501 err = nc_put_varm_uint(ncidistartedgestrideimapvalue);
#10522     edge[j] = mid[j];
#10525     edge[j] = var_shape[i][j] - mid[j];
#10527 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#10536                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#10611    size_t edge[MAX_RANK];
#10654     edge[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);
#10675 edge[j] = var_shape[i][j] + 1;
#10676 err = nc_put_varm_longlong(ncidistartedgestrideimapvalue);
#10679 edge[j] = 1;
#10681 err = nc_put_varm_longlong(ncidistartedgestrideimapvalue);
#10702     edge[j] = mid[j];
#10705     edge[j] = var_shape[i][j] - mid[j];
#10707 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#10716                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#10791    size_t edge[MAX_RANK];
#10834     edge[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);
#10855 edge[j] = var_shape[i][j] + 1;
#10856 err = nc_put_varm_ulonglong(ncidistartedgestrideimapvalue);
#10859 edge[j] = 1;
#10861 err = nc_put_varm_ulonglong(ncidistartedgestrideimapvalue);
#10882     edge[j] = mid[j];
#10885     edge[j] = var_shape[i][j] - mid[j];
#10887 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#10896                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
test_read.c#913    size_t edge[MAX_RANK];
#929            edge[j] = 1;
#931        err = nc_get_vara(BAD_IDistartedgebuf);
#934        err = nc_get_vara(ncidBAD_VARIDstartedgebuf);
#939     err = nc_get_vara(ncidistartedgebuf);
#943     edge[j] = var_shape[i][j] + 1;
#944     err = nc_get_vara(ncidistartedgebuf);
#947     edge[j] = 1;
#962                    edge[j] = mid[j];
#965                    edge[j] = var_shape[i][j] - mid[j];
#967                nels *= edge[j];
#972 err = nc_get_vara(ncidistartedgebuf);
#982     err = toMixedBase(jvar_rank[i], edgeindex);
#1036    size_t edge[MAX_RANK];
#1056            edge[j] = 1;
#1059        err = nc_get_vars(BAD_IDistartedgestridebuf);
#1062        err = nc_get_vars(ncidBAD_VARIDstartedgestridebuf);
#1067     err = nc_get_vars(ncidistartedgestridebuf);
#1071     edge[j] = var_shape[i][j] + 1;
#1072     err = nc_get_vars(ncidistartedgestridebuf);
#1075     edge[j] = 1;
#1077     err = nc_get_vars(ncidistartedgestridebuf);
#1097                    edge[j] = mid[j];
#1100                    edge[j] = var_shape[i][j] - mid[j];
#1102 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#1111     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#1202    size_t edge[MAX_RANK];
#1223            edge[j] = 1;
#1233        err = nc_get_varm(BAD_IDistartedgestrideimapbuf);
#1236        err = nc_get_varm(ncidBAD_VARIDstartedgestrideimapbuf);
#1241     err = nc_get_varm(ncidistartedgestrideimapbuf);
#1245     edge[j] = var_shape[i][j] + 1;
#1246     err = nc_get_varm(ncidistartedgestrideimapbuf);
#1249     edge[j] = 1;
#1251     err = nc_get_varm(ncidistartedgestrideimapbuf);
#1270                    edge[j] = mid[j];
#1273                    edge[j] = var_shape[i][j] - mid[j];
#1275 sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#1287 count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
test_write.c#798    size_t edge[MAX_RANK];
#821            edge[j] = 1;
#823        err = nc_put_vara(BAD_IDistartedgebuf);
#826        err = nc_put_vara(ncidBAD_VARIDstartedgebuf);
#832 err = nc_put_vara(ncidistartedgebuf);
#836 edge[j] = var_shape[i][j] + 1;
#837 err = nc_put_vara(ncidistartedgebuf);
#840 edge[j] = 1;
#856                    edge[j] = mid[j];
#859                    edge[j] = var_shape[i][j] - mid[j];
#861                nels *= edge[j];
#865 err = toMixedBase(jvar_rank[i], edgeindex);
#881 err = nc_put_vara(ncidistartedgebuf);
#921    size_t edge[MAX_RANK];
#948            edge[j] = 1;
#951        err = nc_put_vars(BAD_IDistartedgestridebuf);
#954        err = nc_put_vars(ncidBAD_VARIDstartedgestridebuf);
#960 err = nc_put_vars(ncidistartedgestridebuf);
#964 edge[j] = var_shape[i][j] + 1;
#965 err = nc_put_vars(ncidistartedgestridebuf);
#968 edge[j] = 1;
#970 err = nc_put_vars(ncidistartedgestridebuf);
#990                    edge[j] = mid[j];
#993                    edge[j] = var_shape[i][j] - mid[j];
#995                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#1004                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#1075    size_t edge[MAX_RANK];
#1103            edge[j] = 1;
#1126        err = nc_put_varm(BAD_IDistartedgestrideimapbuf);
#1129        err = nc_put_varm(ncidBAD_VARIDstartedgestrideimapbuf);
#1135 err = nc_put_varm(ncidistartedgestrideimapbuf);
#1139 edge[j] = var_shape[i][j] + 1;
#1140 err = nc_put_varm(ncidistartedgestrideimapbuf);
#1143 edge[j] = 1;
#1145 err = nc_put_varm(ncidistartedgestrideimapbuf);
#1165                    edge[j] = mid[j];
#1168                    edge[j] = var_shape[i][j] - mid[j];
#1170                sstride[j] = stride[j] = edge[j] > 0 ? 1+roll(edge[j]) : 1;
#1182 count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
testnc3perf.c#212    long corner[NDIMS], edge[NDIMS], point[NDIMS];
#297     edge[idim] = dims[idim].size;
#301 edge[0], edge[1], edge[2], edge[3]);
#305 if (ncvarput(ncidvarid[iv], corneredge, (void *) v) == -1) {
#319     edge[idim] = 1;
#324 ,edge[0],edge[1],edge[2],edge[3]);
#327 if (ncvarget(ncidvarid[iv], corneredge, (void *) v) == -1)
#339 edge[jdim] = 1;
#343     edge[idim] = dims[idim].size;
#346     ,edge[0],edge[1],edge[2],edge[3]);
#349     if (ncvarget(ncidvarid[iv], corneredge, (void *) v) == -1)
#353     for (ii=corner[idim]; ii < edge[idim]; ii++) {
#366     edge[kdim] = 1;
#371 edge[idim] = dims[idim].size;
#372 edge[jdim] = dims[jdim].size;
#375 ,edge[0],edge[1],edge[2],edge[3]);
#378 if (ncvarget(ncidvarid[iv], corneredge, (void *) v) == -1)
#382 for (ii=corner[idim]; ii < edge[idim]; ii++) {
#383     for (jj=corner[jdim]; jj < edge[jdim]; jj++) {
#388      (ii)*(int)edge[jdim]+jjVF(point))) {
#403 edge[ldim] = 1;
#409     edge[idim] = dims[idim].size;
#410     edge[jdim] = dims[jdim].size;
#411     edge[kdim] = dims[kdim].size;
#414     ,edge[0],edge[1],edge[2],edge[3]);
#417     if (ncvarget(ncidvarid[iv], corneredge,
#422     for (ii=corner[idim]; ii < edge[idim]; ii++) {
#423 for (jj=corner[jdim]; jj < edge[jdim]; jj++) {
#424     for (kk=corner[kdim]; kk < edge[kdim]; kk++) {
#431      ((ii)*(int)edge[jdim]+jj)*
#432      (int)edge[kdim]+kk,VF(point))) {
#446     edge[idim] = dims[idim].size;
#450 ,edge[0],edge[1],edge[2],edge[3]);
#453 if (ncvarget(ncidvarid[iv], corneredge, (void *) v) == -1)
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;


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