bytebuffer.c#171  int j;
#195  for(j=newlen-1,i=index;i<bb->length;i++) {
#196    bb->content[j]=bb->content[j-n];
cache.c#27    int i,j,found,index;
#58        for(found=0,j=0;j<nclistlength(cachenode->vars);j++) {
#59            CDFnodevar = (CDFnode*)nclistget(cachenode->vars,j);
#401    int i,j;
#418        for(nelems=1,j=0;j<nclistlength(var->array.dimsettrans);j++) {
#419            CDFnodedim = (CDFnode*)nclistget(var->array.dimsettrans,j);
cdf.c#219    unsigned int i,j,d;
#248     for(j=0;j<i;j++) {
#249         CDFnodetestnode = (CDFnode*)nclistget(varnodes,j);
#278 for(j=0;j<i;j++) {
#279     CDFnodevar2 = (CDFnode*)nclistget(varnodes,j);
#438    int indexijmatch;
#482                    for(j=0;j<nclistlength(patternparent->subnodes);j++) {
#483                        CDFnodegridfield = (CDFnode*)nclistget(subtemp->subnodes,j);
#598    unsigned int i,j;
#635        for(j=0;j<nclistlength(fullnode->subnodes);j++) {
#636            CDFnodefullsubnode = (CDFnode*)nclistget(fullnode->subnodes,j);
#679    int i,j;
#700        for(j=0;j<noderank;j++) {
#701     CDFnodedim = (CDFnode*)nclistget(node->array.dimset0,j);
#702     CDFnodebasedim = (CDFnode*)nclistget(basenode->array.dimset0,j);
#1087    unsigned int j,k;
#1093 for(j=0;j<nclistlength(node->attributes);j++) {
#1094     NCattributeatt = (NCattribute*)nclistget(node->attributes,j);
cdm_sea_soundings.c#26   int ij;
#33      for (j = 0; j < i + 1; j++)
#34  ((float *)(data[i].temp_vl.p))[j] = 23.5 - j;
constraints.c#140    int i,j;
#155        for(j=0;j<seg->rank;j++) {
#156     CDFnodedim = (CDFnode*)nclistget(dimset,j);
#160         seg->slices[j].declsize = dim->dim.declsize;
#162         dcemakewholeslice(seg->slices+j,dim->dim.declsize);
#386    int i,j;
#411        for(j=0;j<segment->rank;j++) {
#413     DCEsliceslice = &segment->slices[j];
#416     slice->first = startp[dimindex+j];
#417     slice->stride = stridep[dimindex+j];
#418     count = countp[dimindex+j];
#528    int i,j,k;
#543        for(j=i;j<nclistlength(list);j++) {
#544     DCEprojectionp2 = (DCEprojection*)nclistget(list,j);
#555     nclistset(list,j,(void*)NULL);
#567        for(j=i;j<nclistlength(list);j++) {
#568     DCEprojectionp2 = (DCEprojection*)nclistget(list,j);
#607            for(j=0;i<nclistlength(leaf->subnodes);j++) {
#608                CDFnodefield = (CDFnode*)nclistget(leaf->subnodes,j);
#661    int i,j;
#671 for(j=0;j<seg1->rank;j++) {
#672     DCEsliceslice1 = &seg1->slices[j];
#673     DCEsliceslice2 = &seg2->slices[j];
#691    int i,j;
#716        for(j=0;j<localrank;j++) {
#719     slice = &segment->slices[j];
#720     dim = (CDFnode*)nclistget(dimset,j);
#817    int i,j;
#828        for(j=0;j<seg->rank;j++) {
#829     DCEsliceslice = seg->slices+j;
dapalign.c#212    int i,j;
dapattr.c#21    int i,j;
#45 for(j=0;j<attrcount;j++) {
#54     OCCHECK(oc_dds_attr(conn,ocnode,j,&ocname,&ocetype,&nvalues,NULL));
#58         OCCHECK(oc_dds_attr(conn,ocnode,j,NULL,NULL,NULL,values));
#175    unsigned int i,j;
#226            for(j=0;j<nclistlength(dasnodes);j++) {
#227         OCddsnode das2 = (OCddsnode)nclistget(dasnodes,j);
#268        for(j=0;j<nclistlength(varnodes);j++) {
#269     CDFnodedds = (CDFnode*)nclistget(varnodes,j);
#312    unsigned int i,j,k;
#336     for(j=0;j<ocnvalues;j++) {
#338         OCCHECK(oc_inq_dasattr(conn,attnode,j,&ocetype,&stringval));
#354     for(j=0;j<ndodsnodes;j++) {
#357         OCobject attnode = dodsnodes[j];
dapdump.c#21    int stat,i,j,k;
#114 for(j=0;j<var->ndims;j++) {
#115     fprintf(stdout," %d",var->dimids[j]);
#120        for(j=0;j<var->natts;j++) {
#121     NCattributeatt = &var->atts[j];
#127            stat = nc_inq_attname(hdr->ncid,var->varid,j,attname);
#139 j,att->name,nctypetostring(octypetonc(att->etype)),(unsigned long)nvalues);
dapparse.c#405    unsigned int i,j;
#411        for(j=i+1;j<len;j++) {
#412     OCnodejo = (OCnode*)oclistget(list,j);
#416 oclistremove(list,j);
dceconstraints.c#286    int i,j;
#294 for(j=0;j<addedseg->rank;j++) {
#295     if(j < mergedseg->rank)
#296         dceslicecompose(mergedseg->slices+j,addedseg->slices+j,mergedseg->slices+j);
#298 mergedseg->slices[j] = addedseg->slices[j];
dcopy.c#111        int j;
#120        for(j = 0; j < ndims1;j++)
#121   if(dimsizes1[j] != dimsizes2[j])
dumplib.c#1159 int j;
#1162 for(j=0; j < rank-1; j++) {
#1163     nstrings *= tinfo->sides[fidx][j];
escapes.c#220        size_t j = ctable[i].c;
#221        efree(repls[j]);
#222        repls[j] = ctable[i].s;
genbin.c#329 int j;
#332 for(j=0;j<efield->typ.dimset.ndims;j++) {
#333      unsigned int size = efield->typ.dimset.dimsyms[j]->dim.declsize;
#334      dimsizes[j] = size;
genc.c#703    int i,j;
#749         for(j=0;j<efield->typ.dimset.ndims;j++) {
#753     dim = efield->typ.dimset.dimsyms[j];
#853     int j;
#860     for(j=0;j<efield->typ.dimset.ndims;j++) {
#862         Symbole = efield->typ.dimset.dimsyms[j];
#865 bbCat(stmt,(j==0?"":", "));
genchar.c#99            int j;
#104                for(j=0;j<padsize;j++) bbAppend(databuf,fillchar);
#311            int j;
#316                for(j=0;j<padsize;j++) bbAppend(charbuf,fillchar);
genlib.c#1974     size_t j = ctable[i].c;
#1975     free(repls[j]);
#1976     repls[j] = ctable[i].s;
#1993 size_t j;
#1995     j = *cp + 256;
#1997     j = *cp;
#1999  count += lens[j] - 1;
#2018 size_t jlen;
#2021     j = *cp + 256;
#2023     j = *cp;
#2025 len = strlcat(sprepls[j], newlen);
#2027 sp += lens[j];
#2028 newlen -= lens[j];
large_files.c#39   int recijk;
#136         for(j=0; j<J_LENj++) {
#137           var1[j] = (float)(j + (rec+1) * i);
#175         for(j=0; j<J_LENj++)
#177           if (avar1[j] != (float)(j + (rec + 1) * i)) {
#179                    "should be %g !\n", recijavar1[j], (float) (j + (rec + 1)* i));
list.c#196    unsigned long i,j,k,len;
#202        for(j=i+1;j<len;j++) {
#203     if(content[i] == content[j]) {
#205                for(k=j+1;k<len;k++) content[k-1] = content[k];
lookup3.c#821  uint32_t c[HASHSTATE], d[HASHSTATE], i=0, j=0, klm=0, z;
#832      for (j=0; j<8; ++j)   /*------------------------ for each input bit, */
#846     a[i] ^= (k<<j);
#847     a[i] ^= (k>>(8-j));
#849     b[i] ^= ((k+1)<<j);
#850     b[i] ^= ((k+1)>>(8-j));
#871      printf("i %d j %d m %d len %d\n", ijmhlen);
#897  uint32_t j;
#942  i=47; j=0;
#943  hashlittle2(q, sizeof(q), &i, &j);
#949  i=47, j=0;
#950  hashword2(&len, 1, &i, &j);
#961      for (j=0; j<i; ++j) *(b+j)=0;
nc3internal.c#152 size_t iij;
#198 j = 0;
#220          for (; j<ncp->old->vars.nelemsj++) {
#221            if (!IS_RECVAR(ncp->old->vars.value[j]))
#225          if (j < ncp->old->vars.nelems) {
#226            if ((*vpp)->begin < ncp->old->vars.value[j]->begin) {
#230              (*vpp)->begin = ncp->old->vars.value[j]->begin;
#233            j++;
#269 j = 0;
#290                    for (; j<ncp->old->vars.nelemsj++)
#291                        if (IS_RECVAR(ncp->old->vars.value[j]))
#293                    if (j < ncp->old->vars.nelems) {
#294                        if ((*vpp)->begin < ncp->old->vars.value[j]->begin)
#296                            (*vpp)->begin = ncp->old->vars.value[j]->begin;
#297                        j++;
nc4hdf.c#4084    int i,j,na;
#4114            for(j = 0; j < naj++) {
#4115                hid_t aid =  H5Aopen_idx(dsid,(unsigned int)    j);
ncd2dispatch.c#741    int i,j;
#765            for(j=0;j<ncrank;j++) {
#766                CDFnodedim = (CDFnode*)nclistget(vardims,j);
#767                dimids[j] = dim->ncid;
#800     for(j=0;j<nclistlength(var->attributes);j++) {
#801 NCattributeatt = (NCattribute*)nclistget(var->attributes,j);
#1025    int i,j;
#1041        for(j=0;j<nclistlength(var->array.dimsetall);j++) {
#1042     CDFnodedim = (CDFnode*)nclistget(var->array.dimsetall,j);
#1059 for(j=i+1;j<nclistlength(alldims);j++) { /* Sigh, n**2 */
#1060     dupdim = (CDFnode*)nclistget(alldims,j);
#1084        for(j=i+1;j<nclistlength(alldims);j++) {
#1085     CDFnodedim = (CDFnode*)nclistget(alldims,j);
#1099 for(j=0;j<nclistlength(conflicts);j++) {
#1100     CDFnodedim = (CDFnode*)nclistget(conflicts,j);
#1101     dim->dim.index1 = j+1;
#1170 for(j=nclistlength(basedims)-1;j>i;j--) {
#1172      dim2 = (CDFnode*)nclistget(basedims,j);
#1178 nclistremove(basedims,j);
#1808    int i,j;
#1836     for(j=0;j<ndims;j++) {
#1837 CDFnodedim = (CDFnode*)nclistget(node->array.dimset0,j);
#1839     ASSERT((j == (ndims - 1)));
#2105    int i,j;
#2117     for(j=0;j<nclistlength(path);j++) {
#2118 CDFnodenode = (CDFnode*)nclistget(path,j);
#2144    int i,j;
#2149        for(j=0;j<nclistlength(ncdims);j++) {
#2150     CDFnodedim = (CDFnode*)nclistget(ncdims,j);
ncgeny.c#1980     int i,j;
#1988       for(j=i+1;j<stacklen;j++) {
#1989           Symbolelem2 = (Symbol*)listget(stack,j);
nchashmap.c#188    int i,j,index;
#197     for(j=0;j<nclistlength(seq);j+=2) {
#198         keys[index++] = (nchashid)nclistget(seq,j);
nclist.c#196    unsigned long i,j,k,len;
#202        for(j=i+1;j<len;j++) {
#203     if(content[i] == content[j]) {
#205                for(k=j+1;k<len;k++) content[k-1] = content[k];
ncx.c#5211  long ijni;
#5222  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#5223    ni=Min(nelems-j,LOOPCNT);
#5277  long ijni;
#5288  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#5289    ni=Min(nelems-j,LOOPCNT);
#5342  long ijni;
#5353  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#5354    ni=Min(nelems-j,LOOPCNT);
#5407  long ijni;
#5418  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#5419    ni=Min(nelems-j,LOOPCNT);
#5472  long ijni;
#5483  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#5484    ni=Min(nelems-j,LOOPCNT);
#5537  long ijni;
#5548  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#5549    ni=Min(nelems-j,LOOPCNT);
#5602  long ijni;
#5613  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#5614    ni=Min(nelems-j,LOOPCNT);
#5667  long ijni;
#5678  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#5679    ni=Min(nelems-j,LOOPCNT);
#5732  long ijni;
#5743  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#5744    ni=Min(nelems-j,LOOPCNT);
#5797  long ijni;
#5808  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#5809    ni=Min(nelems-j,LOOPCNT);
#6088  long ijni;
#6099  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#6100    ni=Min(nelems-j,LOOPCNT);
#6159  long ijni;
#6170  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#6171    ni=Min(nelems-j,LOOPCNT);
#6229  long ijni;
#6240  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#6241    ni=Min(nelems-j,LOOPCNT);
#6299  long ijni;
#6310  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#6311    ni=Min(nelems-j,LOOPCNT);
#6369  long ijni;
#6380  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#6381    ni=Min(nelems-j,LOOPCNT);
#6439  long ijni;
#6450  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#6451    ni=Min(nelems-j,LOOPCNT);
#6509  long ijni;
#6520  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#6521    ni=Min(nelems-j,LOOPCNT);
#6579  long ijni;
#6590  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#6591    ni=Min(nelems-j,LOOPCNT);
#6649  long ijni;
#6660  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#6661    ni=Min(nelems-j,LOOPCNT);
#6719  long ijni;
#6730  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#6731    ni=Min(nelems-j,LOOPCNT);
#7058  long ijni;
#7069  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#7070    ni=Min(nelems-j,LOOPCNT);
#7124  long ijni;
#7135  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#7136    ni=Min(nelems-j,LOOPCNT);
#7189  long ijni;
#7200  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#7201    ni=Min(nelems-j,LOOPCNT);
#7254  long ijni;
#7265  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#7266    ni=Min(nelems-j,LOOPCNT);
#7319  long ijni;
#7330  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#7331    ni=Min(nelems-j,LOOPCNT);
#7384  long ijni;
#7395  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#7396    ni=Min(nelems-j,LOOPCNT);
#7449  long ijni;
#7460  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#7461    ni=Min(nelems-j,LOOPCNT);
#7514  long ijni;
#7525  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#7526    ni=Min(nelems-j,LOOPCNT);
#7579  long ijni;
#7590  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#7591    ni=Min(nelems-j,LOOPCNT);
#7644  long ijni;
#7655  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#7656    ni=Min(nelems-j,LOOPCNT);
#7935  long ijni;
#7946  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#7947    ni=Min(nelems-j,LOOPCNT);
#8006  long ijni;
#8017  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#8018    ni=Min(nelems-j,LOOPCNT);
#8076  long ijni;
#8087  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#8088    ni=Min(nelems-j,LOOPCNT);
#8146  long ijni;
#8157  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#8158    ni=Min(nelems-j,LOOPCNT);
#8216  long ijni;
#8227  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#8228    ni=Min(nelems-j,LOOPCNT);
#8286  long ijni;
#8297  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#8298    ni=Min(nelems-j,LOOPCNT);
#8356  long ijni;
#8367  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#8368    ni=Min(nelems-j,LOOPCNT);
#8426  long ijni;
#8437  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#8438    ni=Min(nelems-j,LOOPCNT);
#8496  long ijni;
#8507  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#8508    ni=Min(nelems-j,LOOPCNT);
#8566  long ijni;
#8577  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#8578    ni=Min(nelems-j,LOOPCNT);
#8905  long ijni;
#8916  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#8917    ni=Min(nelems-j,LOOPCNT);
#8971  long ijni;
#8982  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#8983    ni=Min(nelems-j,LOOPCNT);
#9036  long ijni;
#9047  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#9048    ni=Min(nelems-j,LOOPCNT);
#9101  long ijni;
#9112  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#9113    ni=Min(nelems-j,LOOPCNT);
#9166  long ijni;
#9177  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#9178    ni=Min(nelems-j,LOOPCNT);
#9231  long ijni;
#9242  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#9243    ni=Min(nelems-j,LOOPCNT);
#9296  long ijni;
#9307  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#9308    ni=Min(nelems-j,LOOPCNT);
#9361  long ijni;
#9372  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#9373    ni=Min(nelems-j,LOOPCNT);
#9426  long ijni;
#9437  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#9438    ni=Min(nelems-j,LOOPCNT);
#9491  long ijni;
#9502  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#9503    ni=Min(nelems-j,LOOPCNT);
#9571  long ijni;
#9582  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#9583    ni=Min(nelems-j,LOOPCNT);
#9642  long ijni;
#9653  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#9654    ni=Min(nelems-j,LOOPCNT);
#9712  long ijni;
#9723  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#9724    ni=Min(nelems-j,LOOPCNT);
#9782  long ijni;
#9794  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#9795    ni=Min(nelems-j,LOOPCNT);
#9851  long ijni;
#9862  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#9863    ni=Min(nelems-j,LOOPCNT);
#9921  long ijni;
#9932  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#9933    ni=Min(nelems-j,LOOPCNT);
#9991  long ijni;
#10002  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#10003    ni=Min(nelems-j,LOOPCNT);
#10061  long ijni;
#10072  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#10073    ni=Min(nelems-j,LOOPCNT);
#10131  long ijni;
#10142  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#10143    ni=Min(nelems-j,LOOPCNT);
#10201  long ijni;
#10212  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#10213    ni=Min(nelems-j,LOOPCNT);
#10288  long ijni;
#10299  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#10300    ni=Min(nelems-j,LOOPCNT);
#10354  long ijni;
#10365  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#10366    ni=Min(nelems-j,LOOPCNT);
#10419  long ijni;
#10430  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#10431    ni=Min(nelems-j,LOOPCNT);
#10484  long ijni;
#10495  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#10496    ni=Min(nelems-j,LOOPCNT);
#10549  long ijni;
#10560  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#10561    ni=Min(nelems-j,LOOPCNT);
#10614  long ijni;
#10625  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#10626    ni=Min(nelems-j,LOOPCNT);
#10679  long ijni;
#10690  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#10691    ni=Min(nelems-j,LOOPCNT);
#10744  long ijni;
#10755  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#10756    ni=Min(nelems-j,LOOPCNT);
#10809  long ijni;
#10820  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#10821    ni=Min(nelems-j,LOOPCNT);
#10874  long ijni;
#10885  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#10886    ni=Min(nelems-j,LOOPCNT);
#10954  long ijni;
#10965  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#10966    ni=Min(nelems-j,LOOPCNT);
#11025  long ijni;
#11036  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#11037    ni=Min(nelems-j,LOOPCNT);
#11095  long ijni;
#11106  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#11107    ni=Min(nelems-j,LOOPCNT);
#11165  long ijni;
#11176  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#11177    ni=Min(nelems-j,LOOPCNT);
#11235  long ijni;
#11246  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#11247    ni=Min(nelems-j,LOOPCNT);
#11305  long ijni;
#11316  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#11317    ni=Min(nelems-j,LOOPCNT);
#11375  long ijni;
#11386  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#11387    ni=Min(nelems-j,LOOPCNT);
#11445  long ijni;
#11456  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#11457    ni=Min(nelems-j,LOOPCNT);
#11515  long ijni;
#11526  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#11527    ni=Min(nelems-j,LOOPCNT);
#11585  long ijni;
#11596  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#11597    ni=Min(nelems-j,LOOPCNT);
#11751  long ijni;
#11762  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#11763    ni=Min(nelems-j,LOOPCNT);
#11816  long ijni;
#11827  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#11828    ni=Min(nelems-j,LOOPCNT);
#11881  long ijni;
#11892  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#11893    ni=Min(nelems-j,LOOPCNT);
#11946  long ijni;
#11957  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#11958    ni=Min(nelems-j,LOOPCNT);
#12011  long ijni;
#12022  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#12023    ni=Min(nelems-j,LOOPCNT);
#12076  long ijni;
#12087  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#12088    ni=Min(nelems-j,LOOPCNT);
#12141  long ijni;
#12152  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#12153    ni=Min(nelems-j,LOOPCNT);
#12206  long ijni;
#12217  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#12218    ni=Min(nelems-j,LOOPCNT);
#12271  long ijni;
#12282  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#12283    ni=Min(nelems-j,LOOPCNT);
#12427  long ijni;
#12438  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#12439    ni=Min(nelems-j,LOOPCNT);
#12497  long ijni;
#12508  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#12509    ni=Min(nelems-j,LOOPCNT);
#12567  long ijni;
#12578  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#12579    ni=Min(nelems-j,LOOPCNT);
#12637  long ijni;
#12648  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#12649    ni=Min(nelems-j,LOOPCNT);
#12707  long ijni;
#12718  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#12719    ni=Min(nelems-j,LOOPCNT);
#12777  long ijni;
#12788  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#12789    ni=Min(nelems-j,LOOPCNT);
#12847  long ijni;
#12858  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#12859    ni=Min(nelems-j,LOOPCNT);
#12917  long ijni;
#12928  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#12929    ni=Min(nelems-j,LOOPCNT);
#12987  long ijni;
#12998  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#12999    ni=Min(nelems-j,LOOPCNT);
#13147  long ijni;
#13158  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#13159    ni=Min(nelems-j,LOOPCNT);
#13212  long ijni;
#13223  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#13224    ni=Min(nelems-j,LOOPCNT);
#13277  long ijni;
#13288  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#13289    ni=Min(nelems-j,LOOPCNT);
#13342  long ijni;
#13353  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#13354    ni=Min(nelems-j,LOOPCNT);
#13407  long ijni;
#13418  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#13419    ni=Min(nelems-j,LOOPCNT);
#13472  long ijni;
#13483  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#13484    ni=Min(nelems-j,LOOPCNT);
#13537  long ijni;
#13548  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#13549    ni=Min(nelems-j,LOOPCNT);
#13602  long ijni;
#13613  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#13614    ni=Min(nelems-j,LOOPCNT);
#13667  long ijni;
#13678  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#13679    ni=Min(nelems-j,LOOPCNT);
#13838  long ijni;
#13849  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#13850    ni=Min(nelems-j,LOOPCNT);
#13908  long ijni;
#13919  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#13920    ni=Min(nelems-j,LOOPCNT);
#13978  long ijni;
#13989  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#13990    ni=Min(nelems-j,LOOPCNT);
#14048  long ijni;
#14059  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#14060    ni=Min(nelems-j,LOOPCNT);
#14118  long ijni;
#14129  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#14130    ni=Min(nelems-j,LOOPCNT);
#14188  long ijni;
#14199  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#14200    ni=Min(nelems-j,LOOPCNT);
#14258  long ijni;
#14269  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#14270    ni=Min(nelems-j,LOOPCNT);
#14328  long ijni;
#14339  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#14340    ni=Min(nelems-j,LOOPCNT);
#14398  long ijni;
#14409  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#14410    ni=Min(nelems-j,LOOPCNT);
#14486  long ijni;
#14497  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#14498    ni=Min(nelems-j,LOOPCNT);
#14552  long ijni;
#14563  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#14564    ni=Min(nelems-j,LOOPCNT);
#14617  long ijni;
#14628  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#14629    ni=Min(nelems-j,LOOPCNT);
#14682  long ijni;
#14693  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#14694    ni=Min(nelems-j,LOOPCNT);
#14747  long ijni;
#14758  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#14759    ni=Min(nelems-j,LOOPCNT);
#14812  long ijni;
#14823  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#14824    ni=Min(nelems-j,LOOPCNT);
#14877  long ijni;
#14888  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#14889    ni=Min(nelems-j,LOOPCNT);
#14942  long ijni;
#14953  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#14954    ni=Min(nelems-j,LOOPCNT);
#15007  long ijni;
#15018  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#15019    ni=Min(nelems-j,LOOPCNT);
#15072  long ijni;
#15083  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#15084    ni=Min(nelems-j,LOOPCNT);
#15152  long ijni;
#15163  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#15164    ni=Min(nelems-j,LOOPCNT);
#15223  long ijni;
#15234  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#15235    ni=Min(nelems-j,LOOPCNT);
#15293  long ijni;
#15304  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#15305    ni=Min(nelems-j,LOOPCNT);
#15363  long ijni;
#15374  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#15375    ni=Min(nelems-j,LOOPCNT);
#15433  long ijni;
#15444  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#15445    ni=Min(nelems-j,LOOPCNT);
#15503  long ijni;
#15514  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#15515    ni=Min(nelems-j,LOOPCNT);
#15573  long ijni;
#15584  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#15585    ni=Min(nelems-j,LOOPCNT);
#15643  long ijni;
#15654  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#15655    ni=Min(nelems-j,LOOPCNT);
#15713  long ijni;
#15724  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#15725    ni=Min(nelems-j,LOOPCNT);
#15783  long ijni;
#15794  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#15795    ni=Min(nelems-j,LOOPCNT);
#15870  long ijni;
#15881  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#15882    ni=Min(nelems-j,LOOPCNT);
#15936  long ijni;
#15947  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#15948    ni=Min(nelems-j,LOOPCNT);
#16001  long ijni;
#16012  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#16013    ni=Min(nelems-j,LOOPCNT);
#16066  long ijni;
#16077  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#16078    ni=Min(nelems-j,LOOPCNT);
#16131  long ijni;
#16142  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#16143    ni=Min(nelems-j,LOOPCNT);
#16196  long ijni;
#16207  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#16208    ni=Min(nelems-j,LOOPCNT);
#16261  long ijni;
#16272  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#16273    ni=Min(nelems-j,LOOPCNT);
#16326  long ijni;
#16337  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#16338    ni=Min(nelems-j,LOOPCNT);
#16391  long ijni;
#16402  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#16403    ni=Min(nelems-j,LOOPCNT);
#16456  long ijni;
#16467  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#16468    ni=Min(nelems-j,LOOPCNT);
#16536  long ijni;
#16547  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#16548    ni=Min(nelems-j,LOOPCNT);
#16607  long ijni;
#16618  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#16619    ni=Min(nelems-j,LOOPCNT);
#16677  long ijni;
#16688  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#16689    ni=Min(nelems-j,LOOPCNT);
#16747  long ijni;
#16758  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#16759    ni=Min(nelems-j,LOOPCNT);
#16817  long ijni;
#16828  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#16829    ni=Min(nelems-j,LOOPCNT);
#16887  long ijni;
#16898  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#16899    ni=Min(nelems-j,LOOPCNT);
#16957  long ijni;
#16968  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#16969    ni=Min(nelems-j,LOOPCNT);
#17027  long ijni;
#17038  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#17039    ni=Min(nelems-j,LOOPCNT);
#17097  long ijni;
#17108  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#17109    ni=Min(nelems-j,LOOPCNT);
#17167  long ijni;
#17178  for (j=0; j<nelems && nrange==0; j+=LOOPCNT) {
#17179    ni=Min(nelems-j,LOOPCNT);
ocdump.c#175 int j;
#177 for(j=0;j<att->nvalues;j++) {
#178     if(j>0) fprintf(stdout,", ");
#179     dumpattvalue(att->etype,att->values,j);
#233     unsigned int j;
#234     for(j=0;j<oclistlength(sliceset);j++) {
#235         OCsliceslice = (OCslice*)oclistget(sliceset,j);
oclist.c#199    size_t i,j,k,len;
#205        for(j=i+1;j<len;j++) {
#206     if(content[i] == content[j]) {
#208                for(k=j+1;k<len;k++) content[k-1] = content[k];
ocnode.c#21    unsigned int i,j;
#35     for(j=0;j<node->array.rank;j++) {
#36 OCnodedim = (OCnode*)oclistget(node->array.dimensions,j);
#37 node->array.sizes[j] = dim->dim.declsize;
#192    unsigned int i,j;
#211 for(j=0;j<attr->nvalues;j++) {ocfree(*strings); strings++;}
#253    unsigned int i,j;
#281 for(j=0;j<oclistlength(das->subnodes);j++) {
#282     OCnodesubnode = (OCnode*)oclistget(das->subnodes,j);
#287            for(j=0;j<oclistlength(dasnodes);j++) {
#288         OCnodedas2 = (OCnode*)oclistget(dasnodes,j);
#313        for(j=0;j<oclistlength(varnodes);j++) {
#314     OCnodedds = (OCnode*)oclistget(varnodes,j);
#452    int i,j;
#479     for(j=0;j<oclistlength(dds->subnodes);j++) {
#480 OCnodedds1 = (OCnode*)oclistget(dds->subnodes,(size_t)j);
#524    int i,j;
#540 for(j=1;j<oclistlength(path)-1;j++) {/* skip top level dataset and node itself*/
#541            OCnodepathnode = (OCnode*)oclistget(path,(size_t)j);
#565    int i,j;
#573     for(j=0;j<oclistlength(node->subnodes);j++) {
#574 OCnodeattnode = (OCnode*)oclistget(node->subnodes,j);
#589            for(j=0;j<oclistlength(ddsroot->subnodes) && !match;j++) {
#590         OCnodedds = (OCnode*)oclistget(ddsroot->subnodes,j);
#609    int i,j;
#627        for(j=0;j<oclistlength(dds->subnodes) && !match;j++) {
#628     OCnodeddsnode = (OCnode*)oclistget(dds->subnodes,j);
ocutil.c#62    unsigned int i,j;
#66 for(j=0;j<rank;j++) {
#67     OCnodedim = (OCnode*)oclistget(node->array.dimensions,j);
#94    unsigned int i,j;
#99     for(j=0;j<att->nvalues;j++) {
#100 char* s = ((char**)att->values)[j];
#430    int i,j;
#453     for(j=i;j<len;j++) {
#454         int c = contents[i+j];
#456     contents[i+j] = ERRFILL;
offsets.c#216    int i,j;
parallel_vara.c#84    int ijranknprocsverbose=1, err;
#120        for (j=0; j<NXj++)
#121             buf[i][j] = rank;
semantics.c#203    unsigned long i,j;
#228     for(j=0;j<listlength(sym->subnodes);j++) {
#229 Symbolecon = (Symbol*)listget(sym->subnodes,j);
#238     for(j=0;j<listlength(sym->subnodes);j++) {
#239 Symbolfield = (Symbol*)listget(sym->subnodes,j);
#262    unsigned long i,j;
#284     for(j=0;j<listlength(sym->subnodes);j++) {
#285 Symbolfield = (Symbol*)listget(sym->subnodes,j);
#315         for(j=0;j<listlength(sym->subnodes);j++) {
#316     Symbolfield = (Symbol*)listget(sym->subnodes,j);
#356    unsigned long j;
#363     for(j=0;j<listlength(tsym->subnodes);j++) {
#364 Symbolfield = (Symbol*)listget(tsym->subnodes,j);
#389    unsigned long i,j;
#395 for(j=0;j<listlength(sym->subnodes);j++) {
#396     Symbolesym = (Symbol*)listget(sym->subnodes,j);
#406 for(j=0;j<listlength(tsym->subnodes);j++) {
#407     Symbolesym = (Symbol*)listget(tsym->subnodes,j);
#565    int i,j;
#571 for(j=0;j<listlength(candidates);j++) {
#572     Symbolec = (Symbol*)listget(candidates,j);
#679    int i,j;
#694 for(j=0;j<vsym->typ.dimset.ndims;j++) {
#697     if(vsym->typ.dimset.dimsyms[j]->dim.declsize == NC_UNLIMITED) {
#698         if(usingclassic && j != 0)
#723    int i,j;
#774        for(j=0;j<listlength(attdefs);j++) {
#775     Symbolasym = (Symbol*)listget(attdefs,j);
#1181     int j;
#1182     for(j=0;j<var->data->length;j++) {
#1183         NCConstantcon = var->data->data+j;
t_dap.c#116    int i,j;
#156 int j;
#158 for(j=0;j<STRLEN;j++) {
#159     if(string3[i][j] > 0
#160        && string3[i][j] != '\n'
#161        && string3[i][j] != '\r'
#162        && string3[i][j] != '\t'
#163        &&(string3[i][j] < ' ' || string3[i][j] >= '\177'))
#164 string3[i][j] = '?';
#172        for(j=0;j<STRLEN;j++) {
#173         if(string3[i][j] != string3_data[i][j]) {report(i,"string3",__LINE__); break;}
t_dap3a.c#117    int i,j;
#156 int j;
#158 for(j=0;j<STRLEN;j++) {
#159     if(string3[i][j] > 0
#160        && string3[i][j] != '\n'
#161        && string3[i][j] != '\r'
#162        && string3[i][j] != '\t'
#163        &&(string3[i][j] < ' ' || string3[i][j] >= '\177'))
#164 string3[i][j] = '?';
#172        for(j=0;j<STRLEN;j++) {
#173         if(string3[i][j] != string3_data[i][j]) {report(i,"string3",__LINE__); break;}
test_cvt.c#116    int i,j;
#156 int j;
#158 for(j=0;j<STRLEN;j++) {
#159     if(string3_tst[i][j] > 0
#160        && string3_tst[i][j] != '\n'
#161        && string3_tst[i][j] != '\r'
#162        && string3_tst[i][j] != '\t'
#163        &&(string3_tst[i][j] < ' ' || string3_tst[i][j] >= '\177'))
#164 string3_tst[i][j] = '?';
#172        for(j=0;j<STRLEN;j++) {
#173         if(string3_tst[i][j] != string3_data[i][j]) {report(i,"string3",__LINE__); break;}
test_get.c#21    int j;
#34 for (j = 0; j < var_rank[i]; j++)
#35     index[j] = 0;
#42 for (j = 0; j < var_rank[i]; j++) {
#43     index[j] = var_shape[i][j];
#50     index[j] = 0;
#52 for (j = 0; j < var_nels[i]; j++) {
#53     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#99    int j;
#112 for (j = 0; j < var_rank[i]; j++)
#113     index[j] = 0;
#120 for (j = 0; j < var_rank[i]; j++) {
#121     index[j] = var_shape[i][j];
#128     index[j] = 0;
#130 for (j = 0; j < var_nels[i]; j++) {
#131     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#177    int j;
#190 for (j = 0; j < var_rank[i]; j++)
#191     index[j] = 0;
#198 for (j = 0; j < var_rank[i]; j++) {
#199     index[j] = var_shape[i][j];
#206     index[j] = 0;
#208 for (j = 0; j < var_nels[i]; j++) {
#209     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#255    int j;
#268 for (j = 0; j < var_rank[i]; j++)
#269     index[j] = 0;
#276 for (j = 0; j < var_rank[i]; j++) {
#277     index[j] = var_shape[i][j];
#284     index[j] = 0;
#286 for (j = 0; j < var_nels[i]; j++) {
#287     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#333    int j;
#346 for (j = 0; j < var_rank[i]; j++)
#347     index[j] = 0;
#354 for (j = 0; j < var_rank[i]; j++) {
#355     index[j] = var_shape[i][j];
#362     index[j] = 0;
#364 for (j = 0; j < var_nels[i]; j++) {
#365     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#411    int j;
#424 for (j = 0; j < var_rank[i]; j++)
#425     index[j] = 0;
#432 for (j = 0; j < var_rank[i]; j++) {
#433     index[j] = var_shape[i][j];
#440     index[j] = 0;
#442 for (j = 0; j < var_nels[i]; j++) {
#443     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#489    int j;
#502 for (j = 0; j < var_rank[i]; j++)
#503     index[j] = 0;
#510 for (j = 0; j < var_rank[i]; j++) {
#511     index[j] = var_shape[i][j];
#518     index[j] = 0;
#520 for (j = 0; j < var_nels[i]; j++) {
#521     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#567    int j;
#580 for (j = 0; j < var_rank[i]; j++)
#581     index[j] = 0;
#588 for (j = 0; j < var_rank[i]; j++) {
#589     index[j] = var_shape[i][j];
#596     index[j] = 0;
#598 for (j = 0; j < var_nels[i]; j++) {
#599     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#645    int j;
#658 for (j = 0; j < var_rank[i]; j++)
#659     index[j] = 0;
#666 for (j = 0; j < var_rank[i]; j++) {
#667     index[j] = var_shape[i][j];
#674     index[j] = 0;
#676 for (j = 0; j < var_nels[i]; j++) {
#677     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#723    int j;
#736 for (j = 0; j < var_rank[i]; j++)
#737     index[j] = 0;
#744 for (j = 0; j < var_rank[i]; j++) {
#745     index[j] = var_shape[i][j];
#752     index[j] = 0;
#754 for (j = 0; j < var_nels[i]; j++) {
#755     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#801    int j;
#814 for (j = 0; j < var_rank[i]; j++)
#815     index[j] = 0;
#822 for (j = 0; j < var_rank[i]; j++) {
#823     index[j] = var_shape[i][j];
#830     index[j] = 0;
#832 for (j = 0; j < var_nels[i]; j++) {
#833     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#879    int j;
#892 for (j = 0; j < var_rank[i]; j++)
#893     index[j] = 0;
#900 for (j = 0; j < var_rank[i]; j++) {
#901     index[j] = var_shape[i][j];
#908     index[j] = 0;
#910 for (j = 0; j < var_nels[i]; j++) {
#911     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#960    int j;
#986 for (j = 0; j < var_rank[i]; j++) {
#987     nels *= var_shape[i][j];
#990 for (j = 0; j < nelsj++) {
#991     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#994     expect[j] = hash4(var_type[i], var_rank[i], indexNCT_TEXT);
#995     if (inRange3(expect[j],var_type[i], NCT_TEXT)) {
#996 allInIntRange = allInIntRange && expect[j] >= text_min
#997     && expect[j] <= text_max;
#1016     for (j = 0; j < nelsj++) {
#1017 if (inRange3(expect[j],var_type[i],NCT_TEXT)
#1018 && expect[j] >= text_min && expect[j] <= text_max) {
#1019     IF (!equal(value[j],expect[j],var_type[i],NCT_TEXT)){
#1025     error("element number: %d ", j);
#1026     error("expect: %g", expect[j]);
#1027     error("got: %g", (double) value[j]);
#1050    int j;
#1076 for (j = 0; j < var_rank[i]; j++) {
#1077     nels *= var_shape[i][j];
#1080 for (j = 0; j < nelsj++) {
#1081     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1084     expect[j] = hash4(var_type[i], var_rank[i], indexNCT_UCHAR);
#1085     if (inRange3(expect[j],var_type[i], NCT_UCHAR)) {
#1086 allInIntRange = allInIntRange && expect[j] >= uchar_min
#1087     && expect[j] <= uchar_max;
#1106     for (j = 0; j < nelsj++) {
#1107 if (inRange3(expect[j],var_type[i],NCT_UCHAR)
#1108 && expect[j] >= uchar_min && expect[j] <= uchar_max) {
#1109     IF (!equal(value[j],expect[j],var_type[i],NCT_UCHAR)){
#1115     error("element number: %d ", j);
#1116     error("expect: %g", expect[j]);
#1117     error("got: %g", (double) value[j]);
#1140    int j;
#1166 for (j = 0; j < var_rank[i]; j++) {
#1167     nels *= var_shape[i][j];
#1170 for (j = 0; j < nelsj++) {
#1171     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1174     expect[j] = hash4(var_type[i], var_rank[i], indexNCT_SCHAR);
#1175     if (inRange3(expect[j],var_type[i], NCT_SCHAR)) {
#1176 allInIntRange = allInIntRange && expect[j] >= schar_min
#1177     && expect[j] <= schar_max;
#1196     for (j = 0; j < nelsj++) {
#1197 if (inRange3(expect[j],var_type[i],NCT_SCHAR)
#1198 && expect[j] >= schar_min && expect[j] <= schar_max) {
#1199     IF (!equal(value[j],expect[j],var_type[i],NCT_SCHAR)){
#1205     error("element number: %d ", j);
#1206     error("expect: %g", expect[j]);
#1207     error("got: %g", (double) value[j]);
#1230    int j;
#1256 for (j = 0; j < var_rank[i]; j++) {
#1257     nels *= var_shape[i][j];
#1260 for (j = 0; j < nelsj++) {
#1261     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1264     expect[j] = hash4(var_type[i], var_rank[i], indexNCT_SHORT);
#1265     if (inRange3(expect[j],var_type[i], NCT_SHORT)) {
#1266 allInIntRange = allInIntRange && expect[j] >= short_min
#1267     && expect[j] <= short_max;
#1286     for (j = 0; j < nelsj++) {
#1287 if (inRange3(expect[j],var_type[i],NCT_SHORT)
#1288 && expect[j] >= short_min && expect[j] <= short_max) {
#1289     IF (!equal(value[j],expect[j],var_type[i],NCT_SHORT)){
#1295     error("element number: %d ", j);
#1296     error("expect: %g", expect[j]);
#1297     error("got: %g", (double) value[j]);
#1320    int j;
#1346 for (j = 0; j < var_rank[i]; j++) {
#1347     nels *= var_shape[i][j];
#1350 for (j = 0; j < nelsj++) {
#1351     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1354     expect[j] = hash4(var_type[i], var_rank[i], indexNCT_INT);
#1355     if (inRange3(expect[j],var_type[i], NCT_INT)) {
#1356 allInIntRange = allInIntRange && expect[j] >= int_min
#1357     && expect[j] <= int_max;
#1376     for (j = 0; j < nelsj++) {
#1377 if (inRange3(expect[j],var_type[i],NCT_INT)
#1378 && expect[j] >= int_min && expect[j] <= int_max) {
#1379     IF (!equal(value[j],expect[j],var_type[i],NCT_INT)){
#1385     error("element number: %d ", j);
#1386     error("expect: %g", expect[j]);
#1387     error("got: %g", (double) value[j]);
#1410    int j;
#1436 for (j = 0; j < var_rank[i]; j++) {
#1437     nels *= var_shape[i][j];
#1440 for (j = 0; j < nelsj++) {
#1441     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1444     expect[j] = hash4(var_type[i], var_rank[i], indexNCT_LONG);
#1445     if (inRange3(expect[j],var_type[i], NCT_LONG)) {
#1446 allInIntRange = allInIntRange && expect[j] >= long_min
#1447     && expect[j] <= long_max;
#1466     for (j = 0; j < nelsj++) {
#1467 if (inRange3(expect[j],var_type[i],NCT_LONG)
#1468 && expect[j] >= long_min && expect[j] <= long_max) {
#1469     IF (!equal(value[j],expect[j],var_type[i],NCT_LONG)){
#1475     error("element number: %d ", j);
#1476     error("expect: %g", expect[j]);
#1477     error("got: %g", (double) value[j]);
#1500    int j;
#1526 for (j = 0; j < var_rank[i]; j++) {
#1527     nels *= var_shape[i][j];
#1530 for (j = 0; j < nelsj++) {
#1531     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1534     expect[j] = hash4(var_type[i], var_rank[i], indexNCT_FLOAT);
#1535     if (inRange3(expect[j],var_type[i], NCT_FLOAT)) {
#1536 allInIntRange = allInIntRange && expect[j] >= float_min
#1537     && expect[j] <= float_max;
#1556     for (j = 0; j < nelsj++) {
#1557 if (inRange3(expect[j],var_type[i],NCT_FLOAT)
#1558 && expect[j] >= float_min && expect[j] <= float_max) {
#1559     IF (!equal(value[j],expect[j],var_type[i],NCT_FLOAT)){
#1565     error("element number: %d ", j);
#1566     error("expect: %g", expect[j]);
#1567     error("got: %g", (double) value[j]);
#1590    int j;
#1616 for (j = 0; j < var_rank[i]; j++) {
#1617     nels *= var_shape[i][j];
#1620 for (j = 0; j < nelsj++) {
#1621     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1624     expect[j] = hash4(var_type[i], var_rank[i], indexNCT_DOUBLE);
#1625     if (inRange3(expect[j],var_type[i], NCT_DOUBLE)) {
#1626 allInIntRange = allInIntRange && expect[j] >= double_min
#1627     && expect[j] <= double_max;
#1646     for (j = 0; j < nelsj++) {
#1647 if (inRange3(expect[j],var_type[i],NCT_DOUBLE)
#1648 && expect[j] >= double_min && expect[j] <= double_max) {
#1649     IF (!equal(value[j],expect[j],var_type[i],NCT_DOUBLE)){
#1655     error("element number: %d ", j);
#1656     error("expect: %g", expect[j]);
#1657     error("got: %g", (double) value[j]);
#1680    int j;
#1706 for (j = 0; j < var_rank[i]; j++) {
#1707     nels *= var_shape[i][j];
#1710 for (j = 0; j < nelsj++) {
#1711     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1714     expect[j] = hash4(var_type[i], var_rank[i], indexNCT_USHORT);
#1715     if (inRange3(expect[j],var_type[i], NCT_USHORT)) {
#1716 allInIntRange = allInIntRange && expect[j] >= ushort_min
#1717     && expect[j] <= ushort_max;
#1736     for (j = 0; j < nelsj++) {
#1737 if (inRange3(expect[j],var_type[i],NCT_USHORT)
#1738 && expect[j] >= ushort_min && expect[j] <= ushort_max) {
#1739     IF (!equal(value[j],expect[j],var_type[i],NCT_USHORT)){
#1745     error("element number: %d ", j);
#1746     error("expect: %g", expect[j]);
#1747     error("got: %g", (double) value[j]);
#1770    int j;
#1796 for (j = 0; j < var_rank[i]; j++) {
#1797     nels *= var_shape[i][j];
#1800 for (j = 0; j < nelsj++) {
#1801     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1804     expect[j] = hash4(var_type[i], var_rank[i], indexNCT_UINT);
#1805     if (inRange3(expect[j],var_type[i], NCT_UINT)) {
#1806 allInIntRange = allInIntRange && expect[j] >= uint_min
#1807     && expect[j] <= uint_max;
#1826     for (j = 0; j < nelsj++) {
#1827 if (inRange3(expect[j],var_type[i],NCT_UINT)
#1828 && expect[j] >= uint_min && expect[j] <= uint_max) {
#1829     IF (!equal(value[j],expect[j],var_type[i],NCT_UINT)){
#1835     error("element number: %d ", j);
#1836     error("expect: %g", expect[j]);
#1837     error("got: %g", (double) value[j]);
#1860    int j;
#1886 for (j = 0; j < var_rank[i]; j++) {
#1887     nels *= var_shape[i][j];
#1890 for (j = 0; j < nelsj++) {
#1891     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1894     expect[j] = hash4(var_type[i], var_rank[i], indexNCT_LONGLONG);
#1895     if (inRange3(expect[j],var_type[i], NCT_LONGLONG)) {
#1896 allInIntRange = allInIntRange && expect[j] >= longlong_min
#1897     && expect[j] <= longlong_max;
#1916     for (j = 0; j < nelsj++) {
#1917 if (inRange3(expect[j],var_type[i],NCT_LONGLONG)
#1918 && expect[j] >= longlong_min && expect[j] <= longlong_max) {
#1919     IF (!equal(value[j],expect[j],var_type[i],NCT_LONGLONG)){
#1925     error("element number: %d ", j);
#1926     error("expect: %g", expect[j]);
#1927     error("got: %g", (double) value[j]);
#1950    int j;
#1976 for (j = 0; j < var_rank[i]; j++) {
#1977     nels *= var_shape[i][j];
#1980 for (j = 0; j < nelsj++) {
#1981     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1984     expect[j] = hash4(var_type[i], var_rank[i], indexNCT_ULONGLONG);
#1985     if (inRange3(expect[j],var_type[i], NCT_ULONGLONG)) {
#1986 allInIntRange = allInIntRange && expect[j] >= ulonglong_min
#1987     && expect[j] <= ulonglong_max;
#2006     for (j = 0; j < nelsj++) {
#2007 if (inRange3(expect[j],var_type[i],NCT_ULONGLONG)
#2008 && expect[j] >= ulonglong_min && expect[j] <= ulonglong_max) {
#2009     IF (!equal(value[j],expect[j],var_type[i],NCT_ULONGLONG)){
#2015     error("element number: %d ", j);
#2016     error("expect: %g", expect[j]);
#2017     error("got: %g", (double) value[j]);
#2044    int j;
#2067 for (j = 0; j < var_rank[i]; j++) {
#2068     start[j] = 0;
#2069     edge[j] = 1;
#2077 for (j = 0; j < var_rank[i]; j++) {
#2078     start[j] = var_shape[i][j];
#2082     start[j] = 0;
#2083     edge[j] = var_shape[i][j] + 1;
#2087     edge[j] = 1;
#2092     for (j = 0; j < var_rank[i]; j++) {
#2093 edge[j] = 0;
#2109     for (j = 0; j < var_rank[i]; j++) {
#2110 edge[j] = 1;
#2115        for (j = 0; j < var_rank[i]; j++) {
#2116            mid[j] = rollvar_shape[i][j] );
#2122            for (j = 0; j < var_rank[i]; j++) {
#2123                if ((k >> j) & 1) {
#2124                    start[j] = 0;
#2125                    edge[j] = mid[j];
#2127                    start[j] = mid[j];
#2128                    edge[j] = var_shape[i][j] - mid[j];
#2130                nels *= edge[j];
#2133            for (j = 0; j < nelsj++) {
#2134                err = toMixedBase(jvar_rank[i], edgeindex);
#2139                expect[j] = hash4(var_type[i], var_rank[i], indexNCT_TEXT);
#2140 if (inRange3(expect[j],var_type[i], NCT_TEXT)) {
#2141     allInIntRange = allInIntRange && expect[j] >= text_min
#2142 && expect[j] <= text_max;
#2164 for (j = 0; j < nelsj++) {
#2165     if (inRange3(expect[j],var_type[i],NCT_TEXT)
#2166     && expect[j] >= text_min && expect[j] <= text_max) {
#2167 IF (!equal(value[j],expect[j],var_type[i],NCT_TEXT)){
#2173 error("element number: %d ", j);
#2174 error("expect: %g", expect[j]);
#2175 error("got: %g", (double) value[j]);
#2200    int j;
#2223 for (j = 0; j < var_rank[i]; j++) {
#2224     start[j] = 0;
#2225     edge[j] = 1;
#2233 for (j = 0; j < var_rank[i]; j++) {
#2234     start[j] = var_shape[i][j];
#2238     start[j] = 0;
#2239     edge[j] = var_shape[i][j] + 1;
#2243     edge[j] = 1;
#2248     for (j = 0; j < var_rank[i]; j++) {
#2249 edge[j] = 0;
#2265     for (j = 0; j < var_rank[i]; j++) {
#2266 edge[j] = 1;
#2271        for (j = 0; j < var_rank[i]; j++) {
#2272            mid[j] = rollvar_shape[i][j] );
#2278            for (j = 0; j < var_rank[i]; j++) {
#2279                if ((k >> j) & 1) {
#2280                    start[j] = 0;
#2281                    edge[j] = mid[j];
#2283                    start[j] = mid[j];
#2284                    edge[j] = var_shape[i][j] - mid[j];
#2286                nels *= edge[j];
#2289            for (j = 0; j < nelsj++) {
#2290                err = toMixedBase(jvar_rank[i], edgeindex);
#2295                expect[j] = hash4(var_type[i], var_rank[i], indexNCT_UCHAR);
#2296 if (inRange3(expect[j],var_type[i], NCT_UCHAR)) {
#2297     allInIntRange = allInIntRange && expect[j] >= uchar_min
#2298 && expect[j] <= uchar_max;
#2320 for (j = 0; j < nelsj++) {
#2321     if (inRange3(expect[j],var_type[i],NCT_UCHAR)
#2322     && expect[j] >= uchar_min && expect[j] <= uchar_max) {
#2323 IF (!equal(value[j],expect[j],var_type[i],NCT_UCHAR)){
#2329 error("element number: %d ", j);
#2330 error("expect: %g", expect[j]);
#2331 error("got: %g", (double) value[j]);
#2356    int j;
#2379 for (j = 0; j < var_rank[i]; j++) {
#2380     start[j] = 0;
#2381     edge[j] = 1;
#2389 for (j = 0; j < var_rank[i]; j++) {
#2390     start[j] = var_shape[i][j];
#2394     start[j] = 0;
#2395     edge[j] = var_shape[i][j] + 1;
#2399     edge[j] = 1;
#2404     for (j = 0; j < var_rank[i]; j++) {
#2405 edge[j] = 0;
#2421     for (j = 0; j < var_rank[i]; j++) {
#2422 edge[j] = 1;
#2427        for (j = 0; j < var_rank[i]; j++) {
#2428            mid[j] = rollvar_shape[i][j] );
#2434            for (j = 0; j < var_rank[i]; j++) {
#2435                if ((k >> j) & 1) {
#2436                    start[j] = 0;
#2437                    edge[j] = mid[j];
#2439                    start[j] = mid[j];
#2440                    edge[j] = var_shape[i][j] - mid[j];
#2442                nels *= edge[j];
#2445            for (j = 0; j < nelsj++) {
#2446                err = toMixedBase(jvar_rank[i], edgeindex);
#2451                expect[j] = hash4(var_type[i], var_rank[i], indexNCT_SCHAR);
#2452 if (inRange3(expect[j],var_type[i], NCT_SCHAR)) {
#2453     allInIntRange = allInIntRange && expect[j] >= schar_min
#2454 && expect[j] <= schar_max;
#2476 for (j = 0; j < nelsj++) {
#2477     if (inRange3(expect[j],var_type[i],NCT_SCHAR)
#2478     && expect[j] >= schar_min && expect[j] <= schar_max) {
#2479 IF (!equal(value[j],expect[j],var_type[i],NCT_SCHAR)){
#2485 error("element number: %d ", j);
#2486 error("expect: %g", expect[j]);
#2487 error("got: %g", (double) value[j]);
#2512    int j;
#2535 for (j = 0; j < var_rank[i]; j++) {
#2536     start[j] = 0;
#2537     edge[j] = 1;
#2545 for (j = 0; j < var_rank[i]; j++) {
#2546     start[j] = var_shape[i][j];
#2550     start[j] = 0;
#2551     edge[j] = var_shape[i][j] + 1;
#2555     edge[j] = 1;
#2560     for (j = 0; j < var_rank[i]; j++) {
#2561 edge[j] = 0;
#2577     for (j = 0; j < var_rank[i]; j++) {
#2578 edge[j] = 1;
#2583        for (j = 0; j < var_rank[i]; j++) {
#2584            mid[j] = rollvar_shape[i][j] );
#2590            for (j = 0; j < var_rank[i]; j++) {
#2591                if ((k >> j) & 1) {
#2592                    start[j] = 0;
#2593                    edge[j] = mid[j];
#2595                    start[j] = mid[j];
#2596                    edge[j] = var_shape[i][j] - mid[j];
#2598                nels *= edge[j];
#2601            for (j = 0; j < nelsj++) {
#2602                err = toMixedBase(jvar_rank[i], edgeindex);
#2607                expect[j] = hash4(var_type[i], var_rank[i], indexNCT_SHORT);
#2608 if (inRange3(expect[j],var_type[i], NCT_SHORT)) {
#2609     allInIntRange = allInIntRange && expect[j] >= short_min
#2610 && expect[j] <= short_max;
#2632 for (j = 0; j < nelsj++) {
#2633     if (inRange3(expect[j],var_type[i],NCT_SHORT)
#2634     && expect[j] >= short_min && expect[j] <= short_max) {
#2635 IF (!equal(value[j],expect[j],var_type[i],NCT_SHORT)){
#2641 error("element number: %d ", j);
#2642 error("expect: %g", expect[j]);
#2643 error("got: %g", (double) value[j]);
#2668    int j;
#2691 for (j = 0; j < var_rank[i]; j++) {
#2692     start[j] = 0;
#2693     edge[j] = 1;
#2701 for (j = 0; j < var_rank[i]; j++) {
#2702     start[j] = var_shape[i][j];
#2706     start[j] = 0;
#2707     edge[j] = var_shape[i][j] + 1;
#2711     edge[j] = 1;
#2716     for (j = 0; j < var_rank[i]; j++) {
#2717 edge[j] = 0;
#2733     for (j = 0; j < var_rank[i]; j++) {
#2734 edge[j] = 1;
#2739        for (j = 0; j < var_rank[i]; j++) {
#2740            mid[j] = rollvar_shape[i][j] );
#2746            for (j = 0; j < var_rank[i]; j++) {
#2747                if ((k >> j) & 1) {
#2748                    start[j] = 0;
#2749                    edge[j] = mid[j];
#2751                    start[j] = mid[j];
#2752                    edge[j] = var_shape[i][j] - mid[j];
#2754                nels *= edge[j];
#2757            for (j = 0; j < nelsj++) {
#2758                err = toMixedBase(jvar_rank[i], edgeindex);
#2763                expect[j] = hash4(var_type[i], var_rank[i], indexNCT_INT);
#2764 if (inRange3(expect[j],var_type[i], NCT_INT)) {
#2765     allInIntRange = allInIntRange && expect[j] >= int_min
#2766 && expect[j] <= int_max;
#2788 for (j = 0; j < nelsj++) {
#2789     if (inRange3(expect[j],var_type[i],NCT_INT)
#2790     && expect[j] >= int_min && expect[j] <= int_max) {
#2791 IF (!equal(value[j],expect[j],var_type[i],NCT_INT)){
#2797 error("element number: %d ", j);
#2798 error("expect: %g", expect[j]);
#2799 error("got: %g", (double) value[j]);
#2824    int j;
#2847 for (j = 0; j < var_rank[i]; j++) {
#2848     start[j] = 0;
#2849     edge[j] = 1;
#2857 for (j = 0; j < var_rank[i]; j++) {
#2858     start[j] = var_shape[i][j];
#2862     start[j] = 0;
#2863     edge[j] = var_shape[i][j] + 1;
#2867     edge[j] = 1;
#2872     for (j = 0; j < var_rank[i]; j++) {
#2873 edge[j] = 0;
#2889     for (j = 0; j < var_rank[i]; j++) {
#2890 edge[j] = 1;
#2895        for (j = 0; j < var_rank[i]; j++) {
#2896            mid[j] = rollvar_shape[i][j] );
#2902            for (j = 0; j < var_rank[i]; j++) {
#2903                if ((k >> j) & 1) {
#2904                    start[j] = 0;
#2905                    edge[j] = mid[j];
#2907                    start[j] = mid[j];
#2908                    edge[j] = var_shape[i][j] - mid[j];
#2910                nels *= edge[j];
#2913            for (j = 0; j < nelsj++) {
#2914                err = toMixedBase(jvar_rank[i], edgeindex);
#2919                expect[j] = hash4(var_type[i], var_rank[i], indexNCT_LONG);
#2920 if (inRange3(expect[j],var_type[i], NCT_LONG)) {
#2921     allInIntRange = allInIntRange && expect[j] >= long_min
#2922 && expect[j] <= long_max;
#2944 for (j = 0; j < nelsj++) {
#2945     if (inRange3(expect[j],var_type[i],NCT_LONG)
#2946     && expect[j] >= long_min && expect[j] <= long_max) {
#2947 IF (!equal(value[j],expect[j],var_type[i],NCT_LONG)){
#2953 error("element number: %d ", j);
#2954 error("expect: %g", expect[j]);
#2955 error("got: %g", (double) value[j]);
#2980    int j;
#3003 for (j = 0; j < var_rank[i]; j++) {
#3004     start[j] = 0;
#3005     edge[j] = 1;
#3013 for (j = 0; j < var_rank[i]; j++) {
#3014     start[j] = var_shape[i][j];
#3018     start[j] = 0;
#3019     edge[j] = var_shape[i][j] + 1;
#3023     edge[j] = 1;
#3028     for (j = 0; j < var_rank[i]; j++) {
#3029 edge[j] = 0;
#3045     for (j = 0; j < var_rank[i]; j++) {
#3046 edge[j] = 1;
#3051        for (j = 0; j < var_rank[i]; j++) {
#3052            mid[j] = rollvar_shape[i][j] );
#3058            for (j = 0; j < var_rank[i]; j++) {
#3059                if ((k >> j) & 1) {
#3060                    start[j] = 0;
#3061                    edge[j] = mid[j];
#3063                    start[j] = mid[j];
#3064                    edge[j] = var_shape[i][j] - mid[j];
#3066                nels *= edge[j];
#3069            for (j = 0; j < nelsj++) {
#3070                err = toMixedBase(jvar_rank[i], edgeindex);
#3075                expect[j] = hash4(var_type[i], var_rank[i], indexNCT_FLOAT);
#3076 if (inRange3(expect[j],var_type[i], NCT_FLOAT)) {
#3077     allInIntRange = allInIntRange && expect[j] >= float_min
#3078 && expect[j] <= float_max;
#3100 for (j = 0; j < nelsj++) {
#3101     if (inRange3(expect[j],var_type[i],NCT_FLOAT)
#3102     && expect[j] >= float_min && expect[j] <= float_max) {
#3103 IF (!equal(value[j],expect[j],var_type[i],NCT_FLOAT)){
#3109 error("element number: %d ", j);
#3110 error("expect: %g", expect[j]);
#3111 error("got: %g", (double) value[j]);
#3136    int j;
#3159 for (j = 0; j < var_rank[i]; j++) {
#3160     start[j] = 0;
#3161     edge[j] = 1;
#3169 for (j = 0; j < var_rank[i]; j++) {
#3170     start[j] = var_shape[i][j];
#3174     start[j] = 0;
#3175     edge[j] = var_shape[i][j] + 1;
#3179     edge[j] = 1;
#3184     for (j = 0; j < var_rank[i]; j++) {
#3185 edge[j] = 0;
#3201     for (j = 0; j < var_rank[i]; j++) {
#3202 edge[j] = 1;
#3207        for (j = 0; j < var_rank[i]; j++) {
#3208            mid[j] = rollvar_shape[i][j] );
#3214            for (j = 0; j < var_rank[i]; j++) {
#3215                if ((k >> j) & 1) {
#3216                    start[j] = 0;
#3217                    edge[j] = mid[j];
#3219                    start[j] = mid[j];
#3220                    edge[j] = var_shape[i][j] - mid[j];
#3222                nels *= edge[j];
#3225            for (j = 0; j < nelsj++) {
#3226                err = toMixedBase(jvar_rank[i], edgeindex);
#3231                expect[j] = hash4(var_type[i], var_rank[i], indexNCT_DOUBLE);
#3232 if (inRange3(expect[j],var_type[i], NCT_DOUBLE)) {
#3233     allInIntRange = allInIntRange && expect[j] >= double_min
#3234 && expect[j] <= double_max;
#3256 for (j = 0; j < nelsj++) {
#3257     if (inRange3(expect[j],var_type[i],NCT_DOUBLE)
#3258     && expect[j] >= double_min && expect[j] <= double_max) {
#3259 IF (!equal(value[j],expect[j],var_type[i],NCT_DOUBLE)){
#3265 error("element number: %d ", j);
#3266 error("expect: %g", expect[j]);
#3267 error("got: %g", (double) value[j]);
#3292    int j;
#3315 for (j = 0; j < var_rank[i]; j++) {
#3316     start[j] = 0;
#3317     edge[j] = 1;
#3325 for (j = 0; j < var_rank[i]; j++) {
#3326     start[j] = var_shape[i][j];
#3330     start[j] = 0;
#3331     edge[j] = var_shape[i][j] + 1;
#3335     edge[j] = 1;
#3340     for (j = 0; j < var_rank[i]; j++) {
#3341 edge[j] = 0;
#3357     for (j = 0; j < var_rank[i]; j++) {
#3358 edge[j] = 1;
#3363        for (j = 0; j < var_rank[i]; j++) {
#3364            mid[j] = rollvar_shape[i][j] );
#3370            for (j = 0; j < var_rank[i]; j++) {
#3371                if ((k >> j) & 1) {
#3372                    start[j] = 0;
#3373                    edge[j] = mid[j];
#3375                    start[j] = mid[j];
#3376                    edge[j] = var_shape[i][j] - mid[j];
#3378                nels *= edge[j];
#3381            for (j = 0; j < nelsj++) {
#3382                err = toMixedBase(jvar_rank[i], edgeindex);
#3387                expect[j] = hash4(var_type[i], var_rank[i], indexNCT_USHORT);
#3388 if (inRange3(expect[j],var_type[i], NCT_USHORT)) {
#3389     allInIntRange = allInIntRange && expect[j] >= ushort_min
#3390 && expect[j] <= ushort_max;
#3412 for (j = 0; j < nelsj++) {
#3413     if (inRange3(expect[j],var_type[i],NCT_USHORT)
#3414     && expect[j] >= ushort_min && expect[j] <= ushort_max) {
#3415 IF (!equal(value[j],expect[j],var_type[i],NCT_USHORT)){
#3421 error("element number: %d ", j);
#3422 error("expect: %g", expect[j]);
#3423 error("got: %g", (double) value[j]);
#3448    int j;
#3471 for (j = 0; j < var_rank[i]; j++) {
#3472     start[j] = 0;
#3473     edge[j] = 1;
#3481 for (j = 0; j < var_rank[i]; j++) {
#3482     start[j] = var_shape[i][j];
#3486     start[j] = 0;
#3487     edge[j] = var_shape[i][j] + 1;
#3491     edge[j] = 1;
#3496     for (j = 0; j < var_rank[i]; j++) {
#3497 edge[j] = 0;
#3513     for (j = 0; j < var_rank[i]; j++) {
#3514 edge[j] = 1;
#3519        for (j = 0; j < var_rank[i]; j++) {
#3520            mid[j] = rollvar_shape[i][j] );
#3526            for (j = 0; j < var_rank[i]; j++) {
#3527                if ((k >> j) & 1) {
#3528                    start[j] = 0;
#3529                    edge[j] = mid[j];
#3531                    start[j] = mid[j];
#3532                    edge[j] = var_shape[i][j] - mid[j];
#3534                nels *= edge[j];
#3537            for (j = 0; j < nelsj++) {
#3538                err = toMixedBase(jvar_rank[i], edgeindex);
#3543                expect[j] = hash4(var_type[i], var_rank[i], indexNCT_UINT);
#3544 if (inRange3(expect[j],var_type[i], NCT_UINT)) {
#3545     allInIntRange = allInIntRange && expect[j] >= uint_min
#3546 && expect[j] <= uint_max;
#3568 for (j = 0; j < nelsj++) {
#3569     if (inRange3(expect[j],var_type[i],NCT_UINT)
#3570     && expect[j] >= uint_min && expect[j] <= uint_max) {
#3571 IF (!equal(value[j],expect[j],var_type[i],NCT_UINT)){
#3577 error("element number: %d ", j);
#3578 error("expect: %g", expect[j]);
#3579 error("got: %g", (double) value[j]);
#3604    int j;
#3627 for (j = 0; j < var_rank[i]; j++) {
#3628     start[j] = 0;
#3629     edge[j] = 1;
#3637 for (j = 0; j < var_rank[i]; j++) {
#3638     start[j] = var_shape[i][j];
#3642     start[j] = 0;
#3643     edge[j] = var_shape[i][j] + 1;
#3647     edge[j] = 1;
#3652     for (j = 0; j < var_rank[i]; j++) {
#3653 edge[j] = 0;
#3669     for (j = 0; j < var_rank[i]; j++) {
#3670 edge[j] = 1;
#3675        for (j = 0; j < var_rank[i]; j++) {
#3676            mid[j] = rollvar_shape[i][j] );
#3682            for (j = 0; j < var_rank[i]; j++) {
#3683                if ((k >> j) & 1) {
#3684                    start[j] = 0;
#3685                    edge[j] = mid[j];
#3687                    start[j] = mid[j];
#3688                    edge[j] = var_shape[i][j] - mid[j];
#3690                nels *= edge[j];
#3693            for (j = 0; j < nelsj++) {
#3694                err = toMixedBase(jvar_rank[i], edgeindex);
#3699                expect[j] = hash4(var_type[i], var_rank[i], indexNCT_LONGLONG);
#3700 if (inRange3(expect[j],var_type[i], NCT_LONGLONG)) {
#3701     allInIntRange = allInIntRange && expect[j] >= longlong_min
#3702 && expect[j] <= longlong_max;
#3724 for (j = 0; j < nelsj++) {
#3725     if (inRange3(expect[j],var_type[i],NCT_LONGLONG)
#3726     && expect[j] >= longlong_min && expect[j] <= longlong_max) {
#3727 IF (!equal(value[j],expect[j],var_type[i],NCT_LONGLONG)){
#3733 error("element number: %d ", j);
#3734 error("expect: %g", expect[j]);
#3735 error("got: %g", (double) value[j]);
#3760    int j;
#3783 for (j = 0; j < var_rank[i]; j++) {
#3784     start[j] = 0;
#3785     edge[j] = 1;
#3793 for (j = 0; j < var_rank[i]; j++) {
#3794     start[j] = var_shape[i][j];
#3798     start[j] = 0;
#3799     edge[j] = var_shape[i][j] + 1;
#3803     edge[j] = 1;
#3808     for (j = 0; j < var_rank[i]; j++) {
#3809 edge[j] = 0;
#3825     for (j = 0; j < var_rank[i]; j++) {
#3826 edge[j] = 1;
#3831        for (j = 0; j < var_rank[i]; j++) {
#3832            mid[j] = rollvar_shape[i][j] );
#3838            for (j = 0; j < var_rank[i]; j++) {
#3839                if ((k >> j) & 1) {
#3840                    start[j] = 0;
#3841                    edge[j] = mid[j];
#3843                    start[j] = mid[j];
#3844                    edge[j] = var_shape[i][j] - mid[j];
#3846                nels *= edge[j];
#3849            for (j = 0; j < nelsj++) {
#3850                err = toMixedBase(jvar_rank[i], edgeindex);
#3855                expect[j] = hash4(var_type[i], var_rank[i], indexNCT_ULONGLONG);
#3856 if (inRange3(expect[j],var_type[i], NCT_ULONGLONG)) {
#3857     allInIntRange = allInIntRange && expect[j] >= ulonglong_min
#3858 && expect[j] <= ulonglong_max;
#3880 for (j = 0; j < nelsj++) {
#3881     if (inRange3(expect[j],var_type[i],NCT_ULONGLONG)
#3882     && expect[j] >= ulonglong_min && expect[j] <= ulonglong_max) {
#3883 IF (!equal(value[j],expect[j],var_type[i],NCT_ULONGLONG)){
#3889 error("element number: %d ", j);
#3890 error("expect: %g", expect[j]);
#3891 error("got: %g", (double) value[j]);
#3919    int j;
#3948        for (j = 0; j < var_rank[i]; j++) {
#3949            start[j] = 0;
#3950            edge[j] = 1;
#3951            stride[j] = 1;
#3959        for (j = 0; j < var_rank[i]; j++) {
#3960            start[j] = var_shape[i][j];
#3968            start[j] = 0;
#3969            edge[j] = var_shape[i][j] + 1;
#3973            edge[j] = 1;
#3974            stride[j] = 0;
#3978            stride[j] = 1;
#3984        for (j = 0; j < var_rank[i]; j++) {
#3985            mid[j] = rollvar_shape[i][j] );
#3992            for (j = 0; j < var_rank[i]; j++) {
#3993                if ((k >> j) & 1) {
#3994                    start[j] = 0;
#3995                    edge[j] = mid[j];
#3997                    start[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;
#4001                nstarts *= stride[j];
#4008                for (j = 0; j < var_rank[i]; j++) {
#4009                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#4010                    nels *= count[j];
#4011                    index[j] += start[j];
#4023 for (j = 0; j < nelsj++) {
#4024     err = toMixedBase(jvar_rank[i], countindex2);
#4029     expect[j] = hash4(var_type[i], var_rank[i], index2,
#4031     if (inRange3(expect[j],var_type[i],NCT_TEXT)) {
#4032 allInIntRange = allInIntRange && expect[j] >= text_min
#4033     && expect[j] <= text_max;
#4055     for (j = 0; j < nelsj++) {
#4056 if (inRange3(expect[j],var_type[i],NCT_TEXT)
#4057 && expect[j] >= text_min && expect[j] <= text_max) {
#4058     IF (!equal(value[j],expect[j],var_type[i], NCT_TEXT)){
#4064     error("element number: %d ", j);
#4065                                    error("expect: %g, ", expect[j]);
#4066     error("got: %g", (double) value[j]);
#4093    int j;
#4122        for (j = 0; j < var_rank[i]; j++) {
#4123            start[j] = 0;
#4124            edge[j] = 1;
#4125            stride[j] = 1;
#4133        for (j = 0; j < var_rank[i]; j++) {
#4134            start[j] = var_shape[i][j];
#4142            start[j] = 0;
#4143            edge[j] = var_shape[i][j] + 1;
#4147            edge[j] = 1;
#4148            stride[j] = 0;
#4152            stride[j] = 1;
#4158        for (j = 0; j < var_rank[i]; j++) {
#4159            mid[j] = rollvar_shape[i][j] );
#4166            for (j = 0; j < var_rank[i]; j++) {
#4167                if ((k >> j) & 1) {
#4168                    start[j] = 0;
#4169                    edge[j] = mid[j];
#4171                    start[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;
#4175                nstarts *= stride[j];
#4182                for (j = 0; j < var_rank[i]; j++) {
#4183                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#4184                    nels *= count[j];
#4185                    index[j] += start[j];
#4197 for (j = 0; j < nelsj++) {
#4198     err = toMixedBase(jvar_rank[i], countindex2);
#4203     expect[j] = hash4(var_type[i], var_rank[i], index2,
#4205     if (inRange3(expect[j],var_type[i],NCT_UCHAR)) {
#4206 allInIntRange = allInIntRange && expect[j] >= uchar_min
#4207     && expect[j] <= uchar_max;
#4229     for (j = 0; j < nelsj++) {
#4230 if (inRange3(expect[j],var_type[i],NCT_UCHAR)
#4231 && expect[j] >= uchar_min && expect[j] <= uchar_max) {
#4232     IF (!equal(value[j],expect[j],var_type[i], NCT_UCHAR)){
#4238     error("element number: %d ", j);
#4239                                    error("expect: %g, ", expect[j]);
#4240     error("got: %g", (double) value[j]);
#4267    int j;
#4296        for (j = 0; j < var_rank[i]; j++) {
#4297            start[j] = 0;
#4298            edge[j] = 1;
#4299            stride[j] = 1;
#4307        for (j = 0; j < var_rank[i]; j++) {
#4308            start[j] = var_shape[i][j];
#4316            start[j] = 0;
#4317            edge[j] = var_shape[i][j] + 1;
#4321            edge[j] = 1;
#4322            stride[j] = 0;
#4326            stride[j] = 1;
#4332        for (j = 0; j < var_rank[i]; j++) {
#4333            mid[j] = rollvar_shape[i][j] );
#4340            for (j = 0; j < var_rank[i]; j++) {
#4341                if ((k >> j) & 1) {
#4342                    start[j] = 0;
#4343                    edge[j] = mid[j];
#4345                    start[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;
#4349                nstarts *= stride[j];
#4356                for (j = 0; j < var_rank[i]; j++) {
#4357                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#4358                    nels *= count[j];
#4359                    index[j] += start[j];
#4371 for (j = 0; j < nelsj++) {
#4372     err = toMixedBase(jvar_rank[i], countindex2);
#4377     expect[j] = hash4(var_type[i], var_rank[i], index2,
#4379     if (inRange3(expect[j],var_type[i],NCT_SCHAR)) {
#4380 allInIntRange = allInIntRange && expect[j] >= schar_min
#4381     && expect[j] <= schar_max;
#4403     for (j = 0; j < nelsj++) {
#4404 if (inRange3(expect[j],var_type[i],NCT_SCHAR)
#4405 && expect[j] >= schar_min && expect[j] <= schar_max) {
#4406     IF (!equal(value[j],expect[j],var_type[i], NCT_SCHAR)){
#4412     error("element number: %d ", j);
#4413                                    error("expect: %g, ", expect[j]);
#4414     error("got: %g", (double) value[j]);
#4441    int j;
#4470        for (j = 0; j < var_rank[i]; j++) {
#4471            start[j] = 0;
#4472            edge[j] = 1;
#4473            stride[j] = 1;
#4481        for (j = 0; j < var_rank[i]; j++) {
#4482            start[j] = var_shape[i][j];
#4490            start[j] = 0;
#4491            edge[j] = var_shape[i][j] + 1;
#4495            edge[j] = 1;
#4496            stride[j] = 0;
#4500            stride[j] = 1;
#4506        for (j = 0; j < var_rank[i]; j++) {
#4507            mid[j] = rollvar_shape[i][j] );
#4514            for (j = 0; j < var_rank[i]; j++) {
#4515                if ((k >> j) & 1) {
#4516                    start[j] = 0;
#4517                    edge[j] = mid[j];
#4519                    start[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;
#4523                nstarts *= stride[j];
#4530                for (j = 0; j < var_rank[i]; j++) {
#4531                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#4532                    nels *= count[j];
#4533                    index[j] += start[j];
#4545 for (j = 0; j < nelsj++) {
#4546     err = toMixedBase(jvar_rank[i], countindex2);
#4551     expect[j] = hash4(var_type[i], var_rank[i], index2,
#4553     if (inRange3(expect[j],var_type[i],NCT_SHORT)) {
#4554 allInIntRange = allInIntRange && expect[j] >= short_min
#4555     && expect[j] <= short_max;
#4577     for (j = 0; j < nelsj++) {
#4578 if (inRange3(expect[j],var_type[i],NCT_SHORT)
#4579 && expect[j] >= short_min && expect[j] <= short_max) {
#4580     IF (!equal(value[j],expect[j],var_type[i], NCT_SHORT)){
#4586     error("element number: %d ", j);
#4587                                    error("expect: %g, ", expect[j]);
#4588     error("got: %g", (double) value[j]);
#4615    int j;
#4644        for (j = 0; j < var_rank[i]; j++) {
#4645            start[j] = 0;
#4646            edge[j] = 1;
#4647            stride[j] = 1;
#4655        for (j = 0; j < var_rank[i]; j++) {
#4656            start[j] = var_shape[i][j];
#4664            start[j] = 0;
#4665            edge[j] = var_shape[i][j] + 1;
#4669            edge[j] = 1;
#4670            stride[j] = 0;
#4674            stride[j] = 1;
#4680        for (j = 0; j < var_rank[i]; j++) {
#4681            mid[j] = rollvar_shape[i][j] );
#4688            for (j = 0; j < var_rank[i]; j++) {
#4689                if ((k >> j) & 1) {
#4690                    start[j] = 0;
#4691                    edge[j] = mid[j];
#4693                    start[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;
#4697                nstarts *= stride[j];
#4704                for (j = 0; j < var_rank[i]; j++) {
#4705                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#4706                    nels *= count[j];
#4707                    index[j] += start[j];
#4719 for (j = 0; j < nelsj++) {
#4720     err = toMixedBase(jvar_rank[i], countindex2);
#4725     expect[j] = hash4(var_type[i], var_rank[i], index2,
#4727     if (inRange3(expect[j],var_type[i],NCT_INT)) {
#4728 allInIntRange = allInIntRange && expect[j] >= int_min
#4729     && expect[j] <= int_max;
#4751     for (j = 0; j < nelsj++) {
#4752 if (inRange3(expect[j],var_type[i],NCT_INT)
#4753 && expect[j] >= int_min && expect[j] <= int_max) {
#4754     IF (!equal(value[j],expect[j],var_type[i], NCT_INT)){
#4760     error("element number: %d ", j);
#4761                                    error("expect: %g, ", expect[j]);
#4762     error("got: %g", (double) value[j]);
#4789    int j;
#4818        for (j = 0; j < var_rank[i]; j++) {
#4819            start[j] = 0;
#4820            edge[j] = 1;
#4821            stride[j] = 1;
#4829        for (j = 0; j < var_rank[i]; j++) {
#4830            start[j] = var_shape[i][j];
#4838            start[j] = 0;
#4839            edge[j] = var_shape[i][j] + 1;
#4843            edge[j] = 1;
#4844            stride[j] = 0;
#4848            stride[j] = 1;
#4854        for (j = 0; j < var_rank[i]; j++) {
#4855            mid[j] = rollvar_shape[i][j] );
#4862            for (j = 0; j < var_rank[i]; j++) {
#4863                if ((k >> j) & 1) {
#4864                    start[j] = 0;
#4865                    edge[j] = mid[j];
#4867                    start[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;
#4871                nstarts *= stride[j];
#4878                for (j = 0; j < var_rank[i]; j++) {
#4879                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#4880                    nels *= count[j];
#4881                    index[j] += start[j];
#4893 for (j = 0; j < nelsj++) {
#4894     err = toMixedBase(jvar_rank[i], countindex2);
#4899     expect[j] = hash4(var_type[i], var_rank[i], index2,
#4901     if (inRange3(expect[j],var_type[i],NCT_LONG)) {
#4902 allInIntRange = allInIntRange && expect[j] >= long_min
#4903     && expect[j] <= long_max;
#4925     for (j = 0; j < nelsj++) {
#4926 if (inRange3(expect[j],var_type[i],NCT_LONG)
#4927 && expect[j] >= long_min && expect[j] <= long_max) {
#4928     IF (!equal(value[j],expect[j],var_type[i], NCT_LONG)){
#4934     error("element number: %d ", j);
#4935                                    error("expect: %g, ", expect[j]);
#4936     error("got: %g", (double) value[j]);
#4963    int j;
#4992        for (j = 0; j < var_rank[i]; j++) {
#4993            start[j] = 0;
#4994            edge[j] = 1;
#4995            stride[j] = 1;
#5003        for (j = 0; j < var_rank[i]; j++) {
#5004            start[j] = var_shape[i][j];
#5012            start[j] = 0;
#5013            edge[j] = var_shape[i][j] + 1;
#5017            edge[j] = 1;
#5018            stride[j] = 0;
#5022            stride[j] = 1;
#5028        for (j = 0; j < var_rank[i]; j++) {
#5029            mid[j] = rollvar_shape[i][j] );
#5036            for (j = 0; j < var_rank[i]; j++) {
#5037                if ((k >> j) & 1) {
#5038                    start[j] = 0;
#5039                    edge[j] = mid[j];
#5041                    start[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;
#5045                nstarts *= stride[j];
#5052                for (j = 0; j < var_rank[i]; j++) {
#5053                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#5054                    nels *= count[j];
#5055                    index[j] += start[j];
#5067 for (j = 0; j < nelsj++) {
#5068     err = toMixedBase(jvar_rank[i], countindex2);
#5073     expect[j] = hash4(var_type[i], var_rank[i], index2,
#5075     if (inRange3(expect[j],var_type[i],NCT_FLOAT)) {
#5076 allInIntRange = allInIntRange && expect[j] >= float_min
#5077     && expect[j] <= float_max;
#5099     for (j = 0; j < nelsj++) {
#5100 if (inRange3(expect[j],var_type[i],NCT_FLOAT)
#5101 && expect[j] >= float_min && expect[j] <= float_max) {
#5102     IF (!equal(value[j],expect[j],var_type[i], NCT_FLOAT)){
#5108     error("element number: %d ", j);
#5109                                    error("expect: %g, ", expect[j]);
#5110     error("got: %g", (double) value[j]);
#5137    int j;
#5166        for (j = 0; j < var_rank[i]; j++) {
#5167            start[j] = 0;
#5168            edge[j] = 1;
#5169            stride[j] = 1;
#5177        for (j = 0; j < var_rank[i]; j++) {
#5178            start[j] = var_shape[i][j];
#5186            start[j] = 0;
#5187            edge[j] = var_shape[i][j] + 1;
#5191            edge[j] = 1;
#5192            stride[j] = 0;
#5196            stride[j] = 1;
#5202        for (j = 0; j < var_rank[i]; j++) {
#5203            mid[j] = rollvar_shape[i][j] );
#5210            for (j = 0; j < var_rank[i]; j++) {
#5211                if ((k >> j) & 1) {
#5212                    start[j] = 0;
#5213                    edge[j] = mid[j];
#5215                    start[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;
#5219                nstarts *= stride[j];
#5226                for (j = 0; j < var_rank[i]; j++) {
#5227                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#5228                    nels *= count[j];
#5229                    index[j] += start[j];
#5241 for (j = 0; j < nelsj++) {
#5242     err = toMixedBase(jvar_rank[i], countindex2);
#5247     expect[j] = hash4(var_type[i], var_rank[i], index2,
#5249     if (inRange3(expect[j],var_type[i],NCT_DOUBLE)) {
#5250 allInIntRange = allInIntRange && expect[j] >= double_min
#5251     && expect[j] <= double_max;
#5273     for (j = 0; j < nelsj++) {
#5274 if (inRange3(expect[j],var_type[i],NCT_DOUBLE)
#5275 && expect[j] >= double_min && expect[j] <= double_max) {
#5276     IF (!equal(value[j],expect[j],var_type[i], NCT_DOUBLE)){
#5282     error("element number: %d ", j);
#5283                                    error("expect: %g, ", expect[j]);
#5284     error("got: %g", (double) value[j]);
#5311    int j;
#5340        for (j = 0; j < var_rank[i]; j++) {
#5341            start[j] = 0;
#5342            edge[j] = 1;
#5343            stride[j] = 1;
#5351        for (j = 0; j < var_rank[i]; j++) {
#5352            start[j] = var_shape[i][j];
#5360            start[j] = 0;
#5361            edge[j] = var_shape[i][j] + 1;
#5365            edge[j] = 1;
#5366            stride[j] = 0;
#5370            stride[j] = 1;
#5376        for (j = 0; j < var_rank[i]; j++) {
#5377            mid[j] = rollvar_shape[i][j] );
#5384            for (j = 0; j < var_rank[i]; j++) {
#5385                if ((k >> j) & 1) {
#5386                    start[j] = 0;
#5387                    edge[j] = mid[j];
#5389                    start[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;
#5393                nstarts *= stride[j];
#5400                for (j = 0; j < var_rank[i]; j++) {
#5401                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#5402                    nels *= count[j];
#5403                    index[j] += start[j];
#5415 for (j = 0; j < nelsj++) {
#5416     err = toMixedBase(jvar_rank[i], countindex2);
#5421     expect[j] = hash4(var_type[i], var_rank[i], index2,
#5423     if (inRange3(expect[j],var_type[i],NCT_USHORT)) {
#5424 allInIntRange = allInIntRange && expect[j] >= ushort_min
#5425     && expect[j] <= ushort_max;
#5447     for (j = 0; j < nelsj++) {
#5448 if (inRange3(expect[j],var_type[i],NCT_USHORT)
#5449 && expect[j] >= ushort_min && expect[j] <= ushort_max) {
#5450     IF (!equal(value[j],expect[j],var_type[i], NCT_USHORT)){
#5456     error("element number: %d ", j);
#5457                                    error("expect: %g, ", expect[j]);
#5458     error("got: %g", (double) value[j]);
#5485    int j;
#5514        for (j = 0; j < var_rank[i]; j++) {
#5515            start[j] = 0;
#5516            edge[j] = 1;
#5517            stride[j] = 1;
#5525        for (j = 0; j < var_rank[i]; j++) {
#5526            start[j] = var_shape[i][j];
#5534            start[j] = 0;
#5535            edge[j] = var_shape[i][j] + 1;
#5539            edge[j] = 1;
#5540            stride[j] = 0;
#5544            stride[j] = 1;
#5550        for (j = 0; j < var_rank[i]; j++) {
#5551            mid[j] = rollvar_shape[i][j] );
#5558            for (j = 0; j < var_rank[i]; j++) {
#5559                if ((k >> j) & 1) {
#5560                    start[j] = 0;
#5561                    edge[j] = mid[j];
#5563                    start[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;
#5567                nstarts *= stride[j];
#5574                for (j = 0; j < var_rank[i]; j++) {
#5575                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#5576                    nels *= count[j];
#5577                    index[j] += start[j];
#5589 for (j = 0; j < nelsj++) {
#5590     err = toMixedBase(jvar_rank[i], countindex2);
#5595     expect[j] = hash4(var_type[i], var_rank[i], index2,
#5597     if (inRange3(expect[j],var_type[i],NCT_UINT)) {
#5598 allInIntRange = allInIntRange && expect[j] >= uint_min
#5599     && expect[j] <= uint_max;
#5621     for (j = 0; j < nelsj++) {
#5622 if (inRange3(expect[j],var_type[i],NCT_UINT)
#5623 && expect[j] >= uint_min && expect[j] <= uint_max) {
#5624     IF (!equal(value[j],expect[j],var_type[i], NCT_UINT)){
#5630     error("element number: %d ", j);
#5631                                    error("expect: %g, ", expect[j]);
#5632     error("got: %g", (double) value[j]);
#5659    int j;
#5688        for (j = 0; j < var_rank[i]; j++) {
#5689            start[j] = 0;
#5690            edge[j] = 1;
#5691            stride[j] = 1;
#5699        for (j = 0; j < var_rank[i]; j++) {
#5700            start[j] = var_shape[i][j];
#5708            start[j] = 0;
#5709            edge[j] = var_shape[i][j] + 1;
#5713            edge[j] = 1;
#5714            stride[j] = 0;
#5718            stride[j] = 1;
#5724        for (j = 0; j < var_rank[i]; j++) {
#5725            mid[j] = rollvar_shape[i][j] );
#5732            for (j = 0; j < var_rank[i]; j++) {
#5733                if ((k >> j) & 1) {
#5734                    start[j] = 0;
#5735                    edge[j] = mid[j];
#5737                    start[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;
#5741                nstarts *= stride[j];
#5748                for (j = 0; j < var_rank[i]; j++) {
#5749                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#5750                    nels *= count[j];
#5751                    index[j] += start[j];
#5763 for (j = 0; j < nelsj++) {
#5764     err = toMixedBase(jvar_rank[i], countindex2);
#5769     expect[j] = hash4(var_type[i], var_rank[i], index2,
#5771     if (inRange3(expect[j],var_type[i],NCT_LONGLONG)) {
#5772 allInIntRange = allInIntRange && expect[j] >= longlong_min
#5773     && expect[j] <= longlong_max;
#5795     for (j = 0; j < nelsj++) {
#5796 if (inRange3(expect[j],var_type[i],NCT_LONGLONG)
#5797 && expect[j] >= longlong_min && expect[j] <= longlong_max) {
#5798     IF (!equal(value[j],expect[j],var_type[i], NCT_LONGLONG)){
#5804     error("element number: %d ", j);
#5805                                    error("expect: %g, ", expect[j]);
#5806     error("got: %g", (double) value[j]);
#5833    int j;
#5862        for (j = 0; j < var_rank[i]; j++) {
#5863            start[j] = 0;
#5864            edge[j] = 1;
#5865            stride[j] = 1;
#5873        for (j = 0; j < var_rank[i]; j++) {
#5874            start[j] = var_shape[i][j];
#5882            start[j] = 0;
#5883            edge[j] = var_shape[i][j] + 1;
#5887            edge[j] = 1;
#5888            stride[j] = 0;
#5892            stride[j] = 1;
#5898        for (j = 0; j < var_rank[i]; j++) {
#5899            mid[j] = rollvar_shape[i][j] );
#5906            for (j = 0; j < var_rank[i]; j++) {
#5907                if ((k >> j) & 1) {
#5908                    start[j] = 0;
#5909                    edge[j] = mid[j];
#5911                    start[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;
#5915                nstarts *= stride[j];
#5922                for (j = 0; j < var_rank[i]; j++) {
#5923                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#5924                    nels *= count[j];
#5925                    index[j] += start[j];
#5937 for (j = 0; j < nelsj++) {
#5938     err = toMixedBase(jvar_rank[i], countindex2);
#5943     expect[j] = hash4(var_type[i], var_rank[i], index2,
#5945     if (inRange3(expect[j],var_type[i],NCT_ULONGLONG)) {
#5946 allInIntRange = allInIntRange && expect[j] >= ulonglong_min
#5947     && expect[j] <= ulonglong_max;
#5969     for (j = 0; j < nelsj++) {
#5970 if (inRange3(expect[j],var_type[i],NCT_ULONGLONG)
#5971 && expect[j] >= ulonglong_min && expect[j] <= ulonglong_max) {
#5972     IF (!equal(value[j],expect[j],var_type[i], NCT_ULONGLONG)){
#5978     error("element number: %d ", j);
#5979                                    error("expect: %g, ", expect[j]);
#5980     error("got: %g", (double) value[j]);
#6010    int j;
#6040        for (j = 0; j < var_rank[i]; j++) {
#6041            start[j] = 0;
#6042            edge[j] = 1;
#6043            stride[j] = 1;
#6044            imap[j] = 1;
#6052        for (j = 0; j < var_rank[i]; j++) {
#6053            start[j] = var_shape[i][j];
#6061            start[j] = 0;
#6062            edge[j] = var_shape[i][j] + 1;
#6066            edge[j] = 1;
#6067            stride[j] = 0;
#6071            stride[j] = 1;
#6077        for (j = 0; j < var_rank[i]; j++) {
#6078            mid[j] = rollvar_shape[i][j] );
#6085            for (j = 0; j < var_rank[i]; j++) {
#6086                if ((k >> j) & 1) {
#6087                    start[j] = 0;
#6088                    edge[j] = mid[j];
#6090                    start[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;
#6094                nstarts *= stride[j];
#6101                for (j = 0; j < var_rank[i]; j++) {
#6102                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#6103                    nels *= count[j];
#6104                    index[j] += start[j];
#6116     j = var_rank[i] - 1;
#6117     imap[j] = 1;
#6118     for (; j > 0; j--)
#6119 imap[j-1] = imap[j] * count[j];
#6122                for (j = 0; j < nelsj++) {
#6123                    err = toMixedBase(jvar_rank[i], countindex2);
#6128                    expect[j] = hash4(var_type[i], var_rank[i], index2,
#6130                    if (inRange3(expect[j],var_type[i],NCT_TEXT)) {
#6131                        allInIntRange = allInIntRange && expect[j] >= text_min
#6132                            && expect[j] <= text_max;
#6154                    for (j = 0; j < nelsj++) {
#6155                        if (inRange3(expect[j],var_type[i],NCT_TEXT)
#6156                                && expect[j] >= text_min
#6157 && expect[j] <= text_max) {
#6158     IF (!equal(value[j],expect[j],var_type[i], NCT_TEXT)){
#6164                                    error("element number: %d ", j);
#6165                                    error("expect: %g, ", expect[j]);
#6166                                    error("got: %g", (double) value[j]);
#6192    int j;
#6222        for (j = 0; j < var_rank[i]; j++) {
#6223            start[j] = 0;
#6224            edge[j] = 1;
#6225            stride[j] = 1;
#6226            imap[j] = 1;
#6234        for (j = 0; j < var_rank[i]; j++) {
#6235            start[j] = var_shape[i][j];
#6243            start[j] = 0;
#6244            edge[j] = var_shape[i][j] + 1;
#6248            edge[j] = 1;
#6249            stride[j] = 0;
#6253            stride[j] = 1;
#6259        for (j = 0; j < var_rank[i]; j++) {
#6260            mid[j] = rollvar_shape[i][j] );
#6267            for (j = 0; j < var_rank[i]; j++) {
#6268                if ((k >> j) & 1) {
#6269                    start[j] = 0;
#6270                    edge[j] = mid[j];
#6272                    start[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;
#6276                nstarts *= stride[j];
#6283                for (j = 0; j < var_rank[i]; j++) {
#6284                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#6285                    nels *= count[j];
#6286                    index[j] += start[j];
#6298     j = var_rank[i] - 1;
#6299     imap[j] = 1;
#6300     for (; j > 0; j--)
#6301 imap[j-1] = imap[j] * count[j];
#6304                for (j = 0; j < nelsj++) {
#6305                    err = toMixedBase(jvar_rank[i], countindex2);
#6310                    expect[j] = hash4(var_type[i], var_rank[i], index2,
#6312                    if (inRange3(expect[j],var_type[i],NCT_UCHAR)) {
#6313                        allInIntRange = allInIntRange && expect[j] >= uchar_min
#6314                            && expect[j] <= uchar_max;
#6336                    for (j = 0; j < nelsj++) {
#6337                        if (inRange3(expect[j],var_type[i],NCT_UCHAR)
#6338                                && expect[j] >= uchar_min
#6339 && expect[j] <= uchar_max) {
#6340     IF (!equal(value[j],expect[j],var_type[i], NCT_UCHAR)){
#6346                                    error("element number: %d ", j);
#6347                                    error("expect: %g, ", expect[j]);
#6348                                    error("got: %g", (double) value[j]);
#6374    int j;
#6404        for (j = 0; j < var_rank[i]; j++) {
#6405            start[j] = 0;
#6406            edge[j] = 1;
#6407            stride[j] = 1;
#6408            imap[j] = 1;
#6416        for (j = 0; j < var_rank[i]; j++) {
#6417            start[j] = var_shape[i][j];
#6425            start[j] = 0;
#6426            edge[j] = var_shape[i][j] + 1;
#6430            edge[j] = 1;
#6431            stride[j] = 0;
#6435            stride[j] = 1;
#6441        for (j = 0; j < var_rank[i]; j++) {
#6442            mid[j] = rollvar_shape[i][j] );
#6449            for (j = 0; j < var_rank[i]; j++) {
#6450                if ((k >> j) & 1) {
#6451                    start[j] = 0;
#6452                    edge[j] = mid[j];
#6454                    start[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;
#6458                nstarts *= stride[j];
#6465                for (j = 0; j < var_rank[i]; j++) {
#6466                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#6467                    nels *= count[j];
#6468                    index[j] += start[j];
#6480     j = var_rank[i] - 1;
#6481     imap[j] = 1;
#6482     for (; j > 0; j--)
#6483 imap[j-1] = imap[j] * count[j];
#6486                for (j = 0; j < nelsj++) {
#6487                    err = toMixedBase(jvar_rank[i], countindex2);
#6492                    expect[j] = hash4(var_type[i], var_rank[i], index2,
#6494                    if (inRange3(expect[j],var_type[i],NCT_SCHAR)) {
#6495                        allInIntRange = allInIntRange && expect[j] >= schar_min
#6496                            && expect[j] <= schar_max;
#6518                    for (j = 0; j < nelsj++) {
#6519                        if (inRange3(expect[j],var_type[i],NCT_SCHAR)
#6520                                && expect[j] >= schar_min
#6521 && expect[j] <= schar_max) {
#6522     IF (!equal(value[j],expect[j],var_type[i], NCT_SCHAR)){
#6528                                    error("element number: %d ", j);
#6529                                    error("expect: %g, ", expect[j]);
#6530                                    error("got: %g", (double) value[j]);
#6556    int j;
#6586        for (j = 0; j < var_rank[i]; j++) {
#6587            start[j] = 0;
#6588            edge[j] = 1;
#6589            stride[j] = 1;
#6590            imap[j] = 1;
#6598        for (j = 0; j < var_rank[i]; j++) {
#6599            start[j] = var_shape[i][j];
#6607            start[j] = 0;
#6608            edge[j] = var_shape[i][j] + 1;
#6612            edge[j] = 1;
#6613            stride[j] = 0;
#6617            stride[j] = 1;
#6623        for (j = 0; j < var_rank[i]; j++) {
#6624            mid[j] = rollvar_shape[i][j] );
#6631            for (j = 0; j < var_rank[i]; j++) {
#6632                if ((k >> j) & 1) {
#6633                    start[j] = 0;
#6634                    edge[j] = mid[j];
#6636                    start[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;
#6640                nstarts *= stride[j];
#6647                for (j = 0; j < var_rank[i]; j++) {
#6648                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#6649                    nels *= count[j];
#6650                    index[j] += start[j];
#6662     j = var_rank[i] - 1;
#6663     imap[j] = 1;
#6664     for (; j > 0; j--)
#6665 imap[j-1] = imap[j] * count[j];
#6668                for (j = 0; j < nelsj++) {
#6669                    err = toMixedBase(jvar_rank[i], countindex2);
#6674                    expect[j] = hash4(var_type[i], var_rank[i], index2,
#6676                    if (inRange3(expect[j],var_type[i],NCT_SHORT)) {
#6677                        allInIntRange = allInIntRange && expect[j] >= short_min
#6678                            && expect[j] <= short_max;
#6700                    for (j = 0; j < nelsj++) {
#6701                        if (inRange3(expect[j],var_type[i],NCT_SHORT)
#6702                                && expect[j] >= short_min
#6703 && expect[j] <= short_max) {
#6704     IF (!equal(value[j],expect[j],var_type[i], NCT_SHORT)){
#6710                                    error("element number: %d ", j);
#6711                                    error("expect: %g, ", expect[j]);
#6712                                    error("got: %g", (double) value[j]);
#6738    int j;
#6768        for (j = 0; j < var_rank[i]; j++) {
#6769            start[j] = 0;
#6770            edge[j] = 1;
#6771            stride[j] = 1;
#6772            imap[j] = 1;
#6780        for (j = 0; j < var_rank[i]; j++) {
#6781            start[j] = var_shape[i][j];
#6789            start[j] = 0;
#6790            edge[j] = var_shape[i][j] + 1;
#6794            edge[j] = 1;
#6795            stride[j] = 0;
#6799            stride[j] = 1;
#6805        for (j = 0; j < var_rank[i]; j++) {
#6806            mid[j] = rollvar_shape[i][j] );
#6813            for (j = 0; j < var_rank[i]; j++) {
#6814                if ((k >> j) & 1) {
#6815                    start[j] = 0;
#6816                    edge[j] = mid[j];
#6818                    start[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;
#6822                nstarts *= stride[j];
#6829                for (j = 0; j < var_rank[i]; j++) {
#6830                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#6831                    nels *= count[j];
#6832                    index[j] += start[j];
#6844     j = var_rank[i] - 1;
#6845     imap[j] = 1;
#6846     for (; j > 0; j--)
#6847 imap[j-1] = imap[j] * count[j];
#6850                for (j = 0; j < nelsj++) {
#6851                    err = toMixedBase(jvar_rank[i], countindex2);
#6856                    expect[j] = hash4(var_type[i], var_rank[i], index2,
#6858                    if (inRange3(expect[j],var_type[i],NCT_INT)) {
#6859                        allInIntRange = allInIntRange && expect[j] >= int_min
#6860                            && expect[j] <= int_max;
#6882                    for (j = 0; j < nelsj++) {
#6883                        if (inRange3(expect[j],var_type[i],NCT_INT)
#6884                                && expect[j] >= int_min
#6885 && expect[j] <= int_max) {
#6886     IF (!equal(value[j],expect[j],var_type[i], NCT_INT)){
#6892                                    error("element number: %d ", j);
#6893                                    error("expect: %g, ", expect[j]);
#6894                                    error("got: %g", (double) value[j]);
#6920    int j;
#6950        for (j = 0; j < var_rank[i]; j++) {
#6951            start[j] = 0;
#6952            edge[j] = 1;
#6953            stride[j] = 1;
#6954            imap[j] = 1;
#6962        for (j = 0; j < var_rank[i]; j++) {
#6963            start[j] = var_shape[i][j];
#6971            start[j] = 0;
#6972            edge[j] = var_shape[i][j] + 1;
#6976            edge[j] = 1;
#6977            stride[j] = 0;
#6981            stride[j] = 1;
#6987        for (j = 0; j < var_rank[i]; j++) {
#6988            mid[j] = rollvar_shape[i][j] );
#6995            for (j = 0; j < var_rank[i]; j++) {
#6996                if ((k >> j) & 1) {
#6997                    start[j] = 0;
#6998                    edge[j] = mid[j];
#7000                    start[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;
#7004                nstarts *= stride[j];
#7011                for (j = 0; j < var_rank[i]; j++) {
#7012                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7013                    nels *= count[j];
#7014                    index[j] += start[j];
#7026     j = var_rank[i] - 1;
#7027     imap[j] = 1;
#7028     for (; j > 0; j--)
#7029 imap[j-1] = imap[j] * count[j];
#7032                for (j = 0; j < nelsj++) {
#7033                    err = toMixedBase(jvar_rank[i], countindex2);
#7038                    expect[j] = hash4(var_type[i], var_rank[i], index2,
#7040                    if (inRange3(expect[j],var_type[i],NCT_LONG)) {
#7041                        allInIntRange = allInIntRange && expect[j] >= long_min
#7042                            && expect[j] <= long_max;
#7064                    for (j = 0; j < nelsj++) {
#7065                        if (inRange3(expect[j],var_type[i],NCT_LONG)
#7066                                && expect[j] >= long_min
#7067 && expect[j] <= long_max) {
#7068     IF (!equal(value[j],expect[j],var_type[i], NCT_LONG)){
#7074                                    error("element number: %d ", j);
#7075                                    error("expect: %g, ", expect[j]);
#7076                                    error("got: %g", (double) value[j]);
#7102    int j;
#7132        for (j = 0; j < var_rank[i]; j++) {
#7133            start[j] = 0;
#7134            edge[j] = 1;
#7135            stride[j] = 1;
#7136            imap[j] = 1;
#7144        for (j = 0; j < var_rank[i]; j++) {
#7145            start[j] = var_shape[i][j];
#7153            start[j] = 0;
#7154            edge[j] = var_shape[i][j] + 1;
#7158            edge[j] = 1;
#7159            stride[j] = 0;
#7163            stride[j] = 1;
#7169        for (j = 0; j < var_rank[i]; j++) {
#7170            mid[j] = rollvar_shape[i][j] );
#7177            for (j = 0; j < var_rank[i]; j++) {
#7178                if ((k >> j) & 1) {
#7179                    start[j] = 0;
#7180                    edge[j] = mid[j];
#7182                    start[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;
#7186                nstarts *= stride[j];
#7193                for (j = 0; j < var_rank[i]; j++) {
#7194                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7195                    nels *= count[j];
#7196                    index[j] += start[j];
#7208     j = var_rank[i] - 1;
#7209     imap[j] = 1;
#7210     for (; j > 0; j--)
#7211 imap[j-1] = imap[j] * count[j];
#7214                for (j = 0; j < nelsj++) {
#7215                    err = toMixedBase(jvar_rank[i], countindex2);
#7220                    expect[j] = hash4(var_type[i], var_rank[i], index2,
#7222                    if (inRange3(expect[j],var_type[i],NCT_FLOAT)) {
#7223                        allInIntRange = allInIntRange && expect[j] >= float_min
#7224                            && expect[j] <= float_max;
#7246                    for (j = 0; j < nelsj++) {
#7247                        if (inRange3(expect[j],var_type[i],NCT_FLOAT)
#7248                                && expect[j] >= float_min
#7249 && expect[j] <= float_max) {
#7250     IF (!equal(value[j],expect[j],var_type[i], NCT_FLOAT)){
#7256                                    error("element number: %d ", j);
#7257                                    error("expect: %g, ", expect[j]);
#7258                                    error("got: %g", (double) value[j]);
#7284    int j;
#7314        for (j = 0; j < var_rank[i]; j++) {
#7315            start[j] = 0;
#7316            edge[j] = 1;
#7317            stride[j] = 1;
#7318            imap[j] = 1;
#7326        for (j = 0; j < var_rank[i]; j++) {
#7327            start[j] = var_shape[i][j];
#7335            start[j] = 0;
#7336            edge[j] = var_shape[i][j] + 1;
#7340            edge[j] = 1;
#7341            stride[j] = 0;
#7345            stride[j] = 1;
#7351        for (j = 0; j < var_rank[i]; j++) {
#7352            mid[j] = rollvar_shape[i][j] );
#7359            for (j = 0; j < var_rank[i]; j++) {
#7360                if ((k >> j) & 1) {
#7361                    start[j] = 0;
#7362                    edge[j] = mid[j];
#7364                    start[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;
#7368                nstarts *= stride[j];
#7375                for (j = 0; j < var_rank[i]; j++) {
#7376                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7377                    nels *= count[j];
#7378                    index[j] += start[j];
#7390     j = var_rank[i] - 1;
#7391     imap[j] = 1;
#7392     for (; j > 0; j--)
#7393 imap[j-1] = imap[j] * count[j];
#7396                for (j = 0; j < nelsj++) {
#7397                    err = toMixedBase(jvar_rank[i], countindex2);
#7402                    expect[j] = hash4(var_type[i], var_rank[i], index2,
#7404                    if (inRange3(expect[j],var_type[i],NCT_DOUBLE)) {
#7405                        allInIntRange = allInIntRange && expect[j] >= double_min
#7406                            && expect[j] <= double_max;
#7428                    for (j = 0; j < nelsj++) {
#7429                        if (inRange3(expect[j],var_type[i],NCT_DOUBLE)
#7430                                && expect[j] >= double_min
#7431 && expect[j] <= double_max) {
#7432     IF (!equal(value[j],expect[j],var_type[i], NCT_DOUBLE)){
#7438                                    error("element number: %d ", j);
#7439                                    error("expect: %g, ", expect[j]);
#7440                                    error("got: %g", (double) value[j]);
#7466    int j;
#7496        for (j = 0; j < var_rank[i]; j++) {
#7497            start[j] = 0;
#7498            edge[j] = 1;
#7499            stride[j] = 1;
#7500            imap[j] = 1;
#7508        for (j = 0; j < var_rank[i]; j++) {
#7509            start[j] = var_shape[i][j];
#7517            start[j] = 0;
#7518            edge[j] = var_shape[i][j] + 1;
#7522            edge[j] = 1;
#7523            stride[j] = 0;
#7527            stride[j] = 1;
#7533        for (j = 0; j < var_rank[i]; j++) {
#7534            mid[j] = rollvar_shape[i][j] );
#7541            for (j = 0; j < var_rank[i]; j++) {
#7542                if ((k >> j) & 1) {
#7543                    start[j] = 0;
#7544                    edge[j] = mid[j];
#7546                    start[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;
#7550                nstarts *= stride[j];
#7557                for (j = 0; j < var_rank[i]; j++) {
#7558                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7559                    nels *= count[j];
#7560                    index[j] += start[j];
#7572     j = var_rank[i] - 1;
#7573     imap[j] = 1;
#7574     for (; j > 0; j--)
#7575 imap[j-1] = imap[j] * count[j];
#7578                for (j = 0; j < nelsj++) {
#7579                    err = toMixedBase(jvar_rank[i], countindex2);
#7584                    expect[j] = hash4(var_type[i], var_rank[i], index2,
#7586                    if (inRange3(expect[j],var_type[i],NCT_USHORT)) {
#7587                        allInIntRange = allInIntRange && expect[j] >= ushort_min
#7588                            && expect[j] <= ushort_max;
#7610                    for (j = 0; j < nelsj++) {
#7611                        if (inRange3(expect[j],var_type[i],NCT_USHORT)
#7612                                && expect[j] >= ushort_min
#7613 && expect[j] <= ushort_max) {
#7614     IF (!equal(value[j],expect[j],var_type[i], NCT_USHORT)){
#7620                                    error("element number: %d ", j);
#7621                                    error("expect: %g, ", expect[j]);
#7622                                    error("got: %g", (double) value[j]);
#7648    int j;
#7678        for (j = 0; j < var_rank[i]; j++) {
#7679            start[j] = 0;
#7680            edge[j] = 1;
#7681            stride[j] = 1;
#7682            imap[j] = 1;
#7690        for (j = 0; j < var_rank[i]; j++) {
#7691            start[j] = var_shape[i][j];
#7699            start[j] = 0;
#7700            edge[j] = var_shape[i][j] + 1;
#7704            edge[j] = 1;
#7705            stride[j] = 0;
#7709            stride[j] = 1;
#7715        for (j = 0; j < var_rank[i]; j++) {
#7716            mid[j] = rollvar_shape[i][j] );
#7723            for (j = 0; j < var_rank[i]; j++) {
#7724                if ((k >> j) & 1) {
#7725                    start[j] = 0;
#7726                    edge[j] = mid[j];
#7728                    start[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;
#7732                nstarts *= stride[j];
#7739                for (j = 0; j < var_rank[i]; j++) {
#7740                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7741                    nels *= count[j];
#7742                    index[j] += start[j];
#7754     j = var_rank[i] - 1;
#7755     imap[j] = 1;
#7756     for (; j > 0; j--)
#7757 imap[j-1] = imap[j] * count[j];
#7760                for (j = 0; j < nelsj++) {
#7761                    err = toMixedBase(jvar_rank[i], countindex2);
#7766                    expect[j] = hash4(var_type[i], var_rank[i], index2,
#7768                    if (inRange3(expect[j],var_type[i],NCT_UINT)) {
#7769                        allInIntRange = allInIntRange && expect[j] >= uint_min
#7770                            && expect[j] <= uint_max;
#7792                    for (j = 0; j < nelsj++) {
#7793                        if (inRange3(expect[j],var_type[i],NCT_UINT)
#7794                                && expect[j] >= uint_min
#7795 && expect[j] <= uint_max) {
#7796     IF (!equal(value[j],expect[j],var_type[i], NCT_UINT)){
#7802                                    error("element number: %d ", j);
#7803                                    error("expect: %g, ", expect[j]);
#7804                                    error("got: %g", (double) value[j]);
#7830    int j;
#7860        for (j = 0; j < var_rank[i]; j++) {
#7861            start[j] = 0;
#7862            edge[j] = 1;
#7863            stride[j] = 1;
#7864            imap[j] = 1;
#7872        for (j = 0; j < var_rank[i]; j++) {
#7873            start[j] = var_shape[i][j];
#7881            start[j] = 0;
#7882            edge[j] = var_shape[i][j] + 1;
#7886            edge[j] = 1;
#7887            stride[j] = 0;
#7891            stride[j] = 1;
#7897        for (j = 0; j < var_rank[i]; j++) {
#7898            mid[j] = rollvar_shape[i][j] );
#7905            for (j = 0; j < var_rank[i]; j++) {
#7906                if ((k >> j) & 1) {
#7907                    start[j] = 0;
#7908                    edge[j] = mid[j];
#7910                    start[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;
#7914                nstarts *= stride[j];
#7921                for (j = 0; j < var_rank[i]; j++) {
#7922                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7923                    nels *= count[j];
#7924                    index[j] += start[j];
#7936     j = var_rank[i] - 1;
#7937     imap[j] = 1;
#7938     for (; j > 0; j--)
#7939 imap[j-1] = imap[j] * count[j];
#7942                for (j = 0; j < nelsj++) {
#7943                    err = toMixedBase(jvar_rank[i], countindex2);
#7948                    expect[j] = hash4(var_type[i], var_rank[i], index2,
#7950                    if (inRange3(expect[j],var_type[i],NCT_LONGLONG)) {
#7951                        allInIntRange = allInIntRange && expect[j] >= longlong_min
#7952                            && expect[j] <= longlong_max;
#7974                    for (j = 0; j < nelsj++) {
#7975                        if (inRange3(expect[j],var_type[i],NCT_LONGLONG)
#7976                                && expect[j] >= longlong_min
#7977 && expect[j] <= longlong_max) {
#7978     IF (!equal(value[j],expect[j],var_type[i], NCT_LONGLONG)){
#7984                                    error("element number: %d ", j);
#7985                                    error("expect: %g, ", expect[j]);
#7986                                    error("got: %g", (double) value[j]);
#8012    int j;
#8042        for (j = 0; j < var_rank[i]; j++) {
#8043            start[j] = 0;
#8044            edge[j] = 1;
#8045            stride[j] = 1;
#8046            imap[j] = 1;
#8054        for (j = 0; j < var_rank[i]; j++) {
#8055            start[j] = var_shape[i][j];
#8063            start[j] = 0;
#8064            edge[j] = var_shape[i][j] + 1;
#8068            edge[j] = 1;
#8069            stride[j] = 0;
#8073            stride[j] = 1;
#8079        for (j = 0; j < var_rank[i]; j++) {
#8080            mid[j] = rollvar_shape[i][j] );
#8087            for (j = 0; j < var_rank[i]; j++) {
#8088                if ((k >> j) & 1) {
#8089                    start[j] = 0;
#8090                    edge[j] = mid[j];
#8092                    start[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;
#8096                nstarts *= stride[j];
#8103                for (j = 0; j < var_rank[i]; j++) {
#8104                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#8105                    nels *= count[j];
#8106                    index[j] += start[j];
#8118     j = var_rank[i] - 1;
#8119     imap[j] = 1;
#8120     for (; j > 0; j--)
#8121 imap[j-1] = imap[j] * count[j];
#8124                for (j = 0; j < nelsj++) {
#8125                    err = toMixedBase(jvar_rank[i], countindex2);
#8130                    expect[j] = hash4(var_type[i], var_rank[i], index2,
#8132                    if (inRange3(expect[j],var_type[i],NCT_ULONGLONG)) {
#8133                        allInIntRange = allInIntRange && expect[j] >= ulonglong_min
#8134                            && expect[j] <= ulonglong_max;
#8156                    for (j = 0; j < nelsj++) {
#8157                        if (inRange3(expect[j],var_type[i],NCT_ULONGLONG)
#8158                                && expect[j] >= ulonglong_min
#8159 && expect[j] <= ulonglong_max) {
#8160     IF (!equal(value[j],expect[j],var_type[i], NCT_ULONGLONG)){
#8166                                    error("element number: %d ", j);
#8167                                    error("expect: %g, ", expect[j]);
#8168                                    error("got: %g", (double) value[j]);
#8196    int j;
#8211        for (j = 0; j < NATTS(i); j++) {
#8212     canConvert = (ATT_TYPE(i,j) == NC_CHAR) == (NCT_TEXT == NCT_TEXT);
#8213     err = nc_get_att_text(BAD_IDiATT_NAME(i,j), value);
#8216     err = nc_get_att_text(ncidBAD_VARIDATT_NAME(i,j), value);
#8223            for (k = 0; k < ATT_LEN(i,j); k++) {
#8224 expect[k] = hash4(ATT_TYPE(i,j), -1, &kNCT_TEXT);
#8225                if (inRange3(expect[k],ATT_TYPE(i,j),NCT_TEXT)) {
#8232     err = nc_get_att_text(ncidiATT_NAME(i,j), value);
#8233            if (canConvert || ATT_LEN(i,j) == 0) {
#8246 for (k = 0; k < ATT_LEN(i,j); k++) {
#8247     if (inRange3(expect[k],ATT_TYPE(i,j),NCT_TEXT)
#8249 IF (!equal(value[k],expect[k],ATT_TYPE(i,j), NCT_TEXT)){
#8254                                error("att_name: %s, ", ATT_NAME(i,j));
#8282    int j;
#8297        for (j = 0; j < NATTS(i); j++) {
#8298     canConvert = (ATT_TYPE(i,j) == NC_CHAR) == (NCT_UCHAR == NCT_TEXT);
#8299     err = nc_get_att_uchar(BAD_IDiATT_NAME(i,j), value);
#8302     err = nc_get_att_uchar(ncidBAD_VARIDATT_NAME(i,j), value);
#8309            for (k = 0; k < ATT_LEN(i,j); k++) {
#8310 expect[k] = hash4(ATT_TYPE(i,j), -1, &kNCT_UCHAR);
#8311                if (inRange3(expect[k],ATT_TYPE(i,j),NCT_UCHAR)) {
#8318     err = nc_get_att_uchar(ncidiATT_NAME(i,j), value);
#8319            if (canConvert || ATT_LEN(i,j) == 0) {
#8332 for (k = 0; k < ATT_LEN(i,j); k++) {
#8333     if (inRange3(expect[k],ATT_TYPE(i,j),NCT_UCHAR)
#8335 IF (!equal(value[k],expect[k],ATT_TYPE(i,j), NCT_UCHAR)){
#8340                                error("att_name: %s, ", ATT_NAME(i,j));
#8368    int j;
#8383        for (j = 0; j < NATTS(i); j++) {
#8384     canConvert = (ATT_TYPE(i,j) == NC_CHAR) == (NCT_SCHAR == NCT_TEXT);
#8385     err = nc_get_att_schar(BAD_IDiATT_NAME(i,j), value);
#8388     err = nc_get_att_schar(ncidBAD_VARIDATT_NAME(i,j), value);
#8395            for (k = 0; k < ATT_LEN(i,j); k++) {
#8396 expect[k] = hash4(ATT_TYPE(i,j), -1, &kNCT_SCHAR);
#8397                if (inRange3(expect[k],ATT_TYPE(i,j),NCT_SCHAR)) {
#8404     err = nc_get_att_schar(ncidiATT_NAME(i,j), value);
#8405            if (canConvert || ATT_LEN(i,j) == 0) {
#8418 for (k = 0; k < ATT_LEN(i,j); k++) {
#8419     if (inRange3(expect[k],ATT_TYPE(i,j),NCT_SCHAR)
#8421 IF (!equal(value[k],expect[k],ATT_TYPE(i,j), NCT_SCHAR)){
#8426                                error("att_name: %s, ", ATT_NAME(i,j));
#8454    int j;
#8469        for (j = 0; j < NATTS(i); j++) {
#8470     canConvert = (ATT_TYPE(i,j) == NC_CHAR) == (NCT_SHORT == NCT_TEXT);
#8471     err = nc_get_att_short(BAD_IDiATT_NAME(i,j), value);
#8474     err = nc_get_att_short(ncidBAD_VARIDATT_NAME(i,j), value);
#8481            for (k = 0; k < ATT_LEN(i,j); k++) {
#8482 expect[k] = hash4(ATT_TYPE(i,j), -1, &kNCT_SHORT);
#8483                if (inRange3(expect[k],ATT_TYPE(i,j),NCT_SHORT)) {
#8490     err = nc_get_att_short(ncidiATT_NAME(i,j), value);
#8491            if (canConvert || ATT_LEN(i,j) == 0) {
#8504 for (k = 0; k < ATT_LEN(i,j); k++) {
#8505     if (inRange3(expect[k],ATT_TYPE(i,j),NCT_SHORT)
#8507 IF (!equal(value[k],expect[k],ATT_TYPE(i,j), NCT_SHORT)){
#8512                                error("att_name: %s, ", ATT_NAME(i,j));
#8540    int j;
#8555        for (j = 0; j < NATTS(i); j++) {
#8556     canConvert = (ATT_TYPE(i,j) == NC_CHAR) == (NCT_INT == NCT_TEXT);
#8557     err = nc_get_att_int(BAD_IDiATT_NAME(i,j), value);
#8560     err = nc_get_att_int(ncidBAD_VARIDATT_NAME(i,j), value);
#8567            for (k = 0; k < ATT_LEN(i,j); k++) {
#8568 expect[k] = hash4(ATT_TYPE(i,j), -1, &kNCT_INT);
#8569                if (inRange3(expect[k],ATT_TYPE(i,j),NCT_INT)) {
#8576     err = nc_get_att_int(ncidiATT_NAME(i,j), value);
#8577            if (canConvert || ATT_LEN(i,j) == 0) {
#8590 for (k = 0; k < ATT_LEN(i,j); k++) {
#8591     if (inRange3(expect[k],ATT_TYPE(i,j),NCT_INT)
#8593 IF (!equal(value[k],expect[k],ATT_TYPE(i,j), NCT_INT)){
#8598                                error("att_name: %s, ", ATT_NAME(i,j));
#8626    int j;
#8641        for (j = 0; j < NATTS(i); j++) {
#8642     canConvert = (ATT_TYPE(i,j) == NC_CHAR) == (NCT_LONG == NCT_TEXT);
#8643     err = nc_get_att_long(BAD_IDiATT_NAME(i,j), value);
#8646     err = nc_get_att_long(ncidBAD_VARIDATT_NAME(i,j), value);
#8653            for (k = 0; k < ATT_LEN(i,j); k++) {
#8654 expect[k] = hash4(ATT_TYPE(i,j), -1, &kNCT_LONG);
#8655                if (inRange3(expect[k],ATT_TYPE(i,j),NCT_LONG)) {
#8662     err = nc_get_att_long(ncidiATT_NAME(i,j), value);
#8663            if (canConvert || ATT_LEN(i,j) == 0) {
#8676 for (k = 0; k < ATT_LEN(i,j); k++) {
#8677     if (inRange3(expect[k],ATT_TYPE(i,j),NCT_LONG)
#8679 IF (!equal(value[k],expect[k],ATT_TYPE(i,j), NCT_LONG)){
#8684                                error("att_name: %s, ", ATT_NAME(i,j));
#8712    int j;
#8727        for (j = 0; j < NATTS(i); j++) {
#8728     canConvert = (ATT_TYPE(i,j) == NC_CHAR) == (NCT_FLOAT == NCT_TEXT);
#8729     err = nc_get_att_float(BAD_IDiATT_NAME(i,j), value);
#8732     err = nc_get_att_float(ncidBAD_VARIDATT_NAME(i,j), value);
#8739            for (k = 0; k < ATT_LEN(i,j); k++) {
#8740 expect[k] = hash4(ATT_TYPE(i,j), -1, &kNCT_FLOAT);
#8741                if (inRange3(expect[k],ATT_TYPE(i,j),NCT_FLOAT)) {
#8748     err = nc_get_att_float(ncidiATT_NAME(i,j), value);
#8749            if (canConvert || ATT_LEN(i,j) == 0) {
#8762 for (k = 0; k < ATT_LEN(i,j); k++) {
#8763     if (inRange3(expect[k],ATT_TYPE(i,j),NCT_FLOAT)
#8765 IF (!equal(value[k],expect[k],ATT_TYPE(i,j), NCT_FLOAT)){
#8770                                error("att_name: %s, ", ATT_NAME(i,j));
#8798    int j;
#8813        for (j = 0; j < NATTS(i); j++) {
#8814     canConvert = (ATT_TYPE(i,j) == NC_CHAR) == (NCT_DOUBLE == NCT_TEXT);
#8815     err = nc_get_att_double(BAD_IDiATT_NAME(i,j), value);
#8818     err = nc_get_att_double(ncidBAD_VARIDATT_NAME(i,j), value);
#8825            for (k = 0; k < ATT_LEN(i,j); k++) {
#8826 expect[k] = hash4(ATT_TYPE(i,j), -1, &kNCT_DOUBLE);
#8827                if (inRange3(expect[k],ATT_TYPE(i,j),NCT_DOUBLE)) {
#8834     err = nc_get_att_double(ncidiATT_NAME(i,j), value);
#8835            if (canConvert || ATT_LEN(i,j) == 0) {
#8848 for (k = 0; k < ATT_LEN(i,j); k++) {
#8849     if (inRange3(expect[k],ATT_TYPE(i,j),NCT_DOUBLE)
#8851 IF (!equal(value[k],expect[k],ATT_TYPE(i,j), NCT_DOUBLE)){
#8856                                error("att_name: %s, ", ATT_NAME(i,j));
#8884    int j;
#8899        for (j = 0; j < NATTS(i); j++) {
#8900     canConvert = (ATT_TYPE(i,j) == NC_CHAR) == (NCT_USHORT == NCT_TEXT);
#8901     err = nc_get_att_ushort(BAD_IDiATT_NAME(i,j), value);
#8904     err = nc_get_att_ushort(ncidBAD_VARIDATT_NAME(i,j), value);
#8911            for (k = 0; k < ATT_LEN(i,j); k++) {
#8912 expect[k] = hash4(ATT_TYPE(i,j), -1, &kNCT_USHORT);
#8913                if (inRange3(expect[k],ATT_TYPE(i,j),NCT_USHORT)) {
#8920     err = nc_get_att_ushort(ncidiATT_NAME(i,j), value);
#8921            if (canConvert || ATT_LEN(i,j) == 0) {
#8934 for (k = 0; k < ATT_LEN(i,j); k++) {
#8935     if (inRange3(expect[k],ATT_TYPE(i,j),NCT_USHORT)
#8937 IF (!equal(value[k],expect[k],ATT_TYPE(i,j), NCT_USHORT)){
#8942                                error("att_name: %s, ", ATT_NAME(i,j));
#8970    int j;
#8985        for (j = 0; j < NATTS(i); j++) {
#8986     canConvert = (ATT_TYPE(i,j) == NC_CHAR) == (NCT_UINT == NCT_TEXT);
#8987     err = nc_get_att_uint(BAD_IDiATT_NAME(i,j), value);
#8990     err = nc_get_att_uint(ncidBAD_VARIDATT_NAME(i,j), value);
#8997            for (k = 0; k < ATT_LEN(i,j); k++) {
#8998 expect[k] = hash4(ATT_TYPE(i,j), -1, &kNCT_UINT);
#8999                if (inRange3(expect[k],ATT_TYPE(i,j),NCT_UINT)) {
#9006     err = nc_get_att_uint(ncidiATT_NAME(i,j), value);
#9007            if (canConvert || ATT_LEN(i,j) == 0) {
#9020 for (k = 0; k < ATT_LEN(i,j); k++) {
#9021     if (inRange3(expect[k],ATT_TYPE(i,j),NCT_UINT)
#9023 IF (!equal(value[k],expect[k],ATT_TYPE(i,j), NCT_UINT)){
#9028                                error("att_name: %s, ", ATT_NAME(i,j));
#9056    int j;
#9071        for (j = 0; j < NATTS(i); j++) {
#9072     canConvert = (ATT_TYPE(i,j) == NC_CHAR) == (NCT_LONGLONG == NCT_TEXT);
#9073     err = nc_get_att_longlong(BAD_IDiATT_NAME(i,j), value);
#9076     err = nc_get_att_longlong(ncidBAD_VARIDATT_NAME(i,j), value);
#9083            for (k = 0; k < ATT_LEN(i,j); k++) {
#9084 expect[k] = hash4(ATT_TYPE(i,j), -1, &kNCT_LONGLONG);
#9085                if (inRange3(expect[k],ATT_TYPE(i,j),NCT_LONGLONG)) {
#9092     err = nc_get_att_longlong(ncidiATT_NAME(i,j), value);
#9093            if (canConvert || ATT_LEN(i,j) == 0) {
#9106 for (k = 0; k < ATT_LEN(i,j); k++) {
#9107     if (inRange3(expect[k],ATT_TYPE(i,j),NCT_LONGLONG)
#9109 IF (!equal(value[k],expect[k],ATT_TYPE(i,j), NCT_LONGLONG)){
#9114                                error("att_name: %s, ", ATT_NAME(i,j));
#9142    int j;
#9157        for (j = 0; j < NATTS(i); j++) {
#9158     canConvert = (ATT_TYPE(i,j) == NC_CHAR) == (NCT_ULONGLONG == NCT_TEXT);
#9159     err = nc_get_att_ulonglong(BAD_IDiATT_NAME(i,j), value);
#9162     err = nc_get_att_ulonglong(ncidBAD_VARIDATT_NAME(i,j), value);
#9169            for (k = 0; k < ATT_LEN(i,j); k++) {
#9170 expect[k] = hash4(ATT_TYPE(i,j), -1, &kNCT_ULONGLONG);
#9171                if (inRange3(expect[k],ATT_TYPE(i,j),NCT_ULONGLONG)) {
#9178     err = nc_get_att_ulonglong(ncidiATT_NAME(i,j), value);
#9179            if (canConvert || ATT_LEN(i,j) == 0) {
#9192 for (k = 0; k < ATT_LEN(i,j); k++) {
#9193     if (inRange3(expect[k],ATT_TYPE(i,j),NCT_ULONGLONG)
#9195 IF (!equal(value[k],expect[k],ATT_TYPE(i,j), NCT_ULONGLONG)){
#9200                                error("att_name: %s, ", ATT_NAME(i,j));
test_put.c#235    size_t  j;
#262     for (j = 0; j < ndimsj++) {
#263 err = nc_inq_dim(nciddimids[j], 0, &length);
#266 IF (length != var_shape[i][j])
#269     for (j = 0; j < var_nels[i]; j++) {
#270 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#319    size_t  j;
#346     for (j = 0; j < ndimsj++) {
#347 err = nc_inq_dim(nciddimids[j], 0, &length);
#350 IF (length != var_shape[i][j])
#353     for (j = 0; j < var_nels[i]; j++) {
#354 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#403    size_t  j;
#430     for (j = 0; j < ndimsj++) {
#431 err = nc_inq_dim(nciddimids[j], 0, &length);
#434 IF (length != var_shape[i][j])
#437     for (j = 0; j < var_nels[i]; j++) {
#438 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#487    size_t  j;
#514     for (j = 0; j < ndimsj++) {
#515 err = nc_inq_dim(nciddimids[j], 0, &length);
#518