cdf.c#1087    unsigned int j,k;
#1096     for(k=0;k<nclistlength(att->values);k++)
#1097 nullfree((char*)nclistget(att->values,k));
constraints.c#528    int i,j,k;
#573     for(k=0;k<nclistlength(tmp);k++) {
#574 void* candidate = (void*)nclistget(tmp,k);
dapattr.c#312    unsigned int i,j,k;
#365         for(k=0;k<ocnvalues;k++) {
#367             OCCHECK(oc_inq_dasattr(conn,attnode,k,&ocetype,&stringval));
dapdump.c#21    int stat,i,j,k;
#73     for(k=0;k<nvalues;k++) {
#75 dumpdata1(octypetonc(att->etype),k,values);
#140     for(k=0;k<nvalues;k++) {
#142 dumpdata1(octypetonc(att->etype),k,values);
large_files.c#39   int recijk;
list.c#196    unsigned long i,j,k,len;
#205                for(k=j+1;k<len;k++) content[k-1] = content[k];
lookup3.c#76#define rot(x,k) (((x)<<(k)) | ((x)>>(32-(k))))
#184const uint32_t *k,                   /* the key, an array of uint32_t values */
#196    a += k[0];
#197    b += k[1];
#198    c += k[2];
#201    k += 3;
#207  case 3 : c+=k[2];
#208  case 2 : b+=k[1];
#209  case 1 : a+=k[0];
#228const uint32_t *k,                   /* the key, an array of uint32_t values */
#242    a += k[0];
#243    b += k[1];
#244    c += k[2];
#247    k += 3;
#253  case 3 : c+=k[2];
#254  case 2 : b+=k[1];
#255  case 1 : a+=k[0];
#290    const uint32_t *k = (const uint32_t *)key;         /* read 32-bit chunks */
#296      a += k[0];
#297      b += k[1];
#298      c += k[2];
#301      k += 3;
#318    case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
#319    case 11: c+=k[2]&0xffffffb+=k[1]; a+=k[0]; break;
#320    case 10: c+=k[2]&0xffffb+=k[1]; a+=k[0]; break;
#321    case 9 : c+=k[2]&0xffb+=k[1]; a+=k[0]; break;
#322    case 8 : b+=k[1]; a+=k[0]; break;
#323    case 7 : b+=k[1]&0xffffffa+=k[0]; break;
#324    case 6 : b+=k[1]&0xffffa+=k[0]; break;
#325    case 5 : b+=k[1]&0xffa+=k[0]; break;
#326    case 4 : a+=k[0]; break;
#327    case 3 : a+=k[0]&0xffffff; break;
#328    case 2 : a+=k[0]&0xffff; break;
#329    case 1 : a+=k[0]&0xff; break;
#335    k8 = (const uint8_t *)k;
#338    case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
#342    case 8 : b+=k[1]; a+=k[0]; break;
#346    case 4 : a+=k[0]; break;
#356    const uint16_t *k = (const uint16_t *)key;         /* read 16-bit chunks */
#362      a += k[0] + (((uint32_t)k[1])<<16);
#363      b += k[2] + (((uint32_t)k[3])<<16);
#364      c += k[4] + (((uint32_t)k[5])<<16);
#367      k += 6;
#371    k8 = (const uint8_t *)k;
#374    case 12: c+=k[4]+(((uint32_t)k[5])<<16);
#375             b+=k[2]+(((uint32_t)k[3])<<16);
#376             a+=k[0]+(((uint32_t)k[1])<<16);
#379    case 10: c+=k[4];
#380             b+=k[2]+(((uint32_t)k[3])<<16);
#381             a+=k[0]+(((uint32_t)k[1])<<16);
#384    case 8 : b+=k[2]+(((uint32_t)k[3])<<16);
#385             a+=k[0]+(((uint32_t)k[1])<<16);
#388    case 6 : b+=k[2];
#389             a+=k[0]+(((uint32_t)k[1])<<16);
#392    case 4 : a+=k[0]+(((uint32_t)k[1])<<16);
#395    case 2 : a+=k[0];
#403    const uint8_t *k = (const uint8_t *)key;
#408      a += k[0];
#409      a += ((uint32_t)k[1])<<8;
#410      a += ((uint32_t)k[2])<<16;
#411      a += ((uint32_t)k[3])<<24;
#412      b += k[4];
#413      b += ((uint32_t)k[5])<<8;
#414      b += ((uint32_t)k[6])<<16;
#415      b += ((uint32_t)k[7])<<24;
#416      c += k[8];
#417      c += ((uint32_t)k[9])<<8;
#418      c += ((uint32_t)k[10])<<16;
#419      c += ((uint32_t)k[11])<<24;
#422      k += 12;
#428    case 12: c+=((uint32_t)k[11])<<24;
#429    case 11: c+=((uint32_t)k[10])<<16;
#430    case 10: c+=((uint32_t)k[9])<<8;
#431    case 9 : c+=k[8];
#432    case 8 : b+=((uint32_t)k[7])<<24;
#433    case 7 : b+=((uint32_t)k[6])<<16;
#434    case 6 : b+=((uint32_t)k[5])<<8;
#435    case 5 : b+=k[4];
#436    case 4 : a+=((uint32_t)k[3])<<24;
#437    case 3 : a+=((uint32_t)k[2])<<16;
#438    case 2 : a+=((uint32_t)k[1])<<8;
#439    case 1 : a+=k[0];
#469    const uint32_t *k = (const uint32_t *)key;         /* read 32-bit chunks */
#475      a += k[0];
#476      b += k[1];
#477      c += k[2];
#480      k += 3;
#497    case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
#498    case 11: c+=k[2]&0xffffff00b+=k[1]; a+=k[0]; break;
#499    case 10: c+=k[2]&0xffff0000b+=k[1]; a+=k[0]; break;
#500    case 9 : c+=k[2]&0xff000000b+=k[1]; a+=k[0]; break;
#501    case 8 : b+=k[1]; a+=k[0]; break;
#502    case 7 : b+=k[1]&0xffffff00a+=k[0]; break;
#503    case 6 : b+=k[1]&0xffff0000a+=k[0]; break;
#504    case 5 : b+=k[1]&0xff000000a+=k[0]; break;
#505    case 4 : a+=k[0]; break;
#506    case 3 : a+=k[0]&0xffffff00; break;
#507    case 2 : a+=k[0]&0xffff0000; break;
#508    case 1 : a+=k[0]&0xff000000; break;
#514    k8 = (const uint8_t *)k;
#517    case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
#521    case 8 : b+=k[1]; a+=k[0]; break;
#525    case 4 : a+=k[0]; break;
#535    const uint8_t *k = (const uint8_t *)key;
#540      a += ((uint32_t)k[0])<<24;
#541      a += ((uint32_t)k[1])<<16;
#542      a += ((uint32_t)k[2])<<8;
#543      a += ((uint32_t)k[3]);
#544      b += ((uint32_t)k[4])<<24;
#545      b += ((uint32_t)k[5])<<16;
#546      b += ((uint32_t)k[6])<<8;
#547      b += ((uint32_t)k[7]);
#548      c += ((uint32_t)k[8])<<24;
#549      c += ((uint32_t)k[9])<<16;
#550      c += ((uint32_t)k[10])<<8;
#551      c += ((uint32_t)k[11]);
#554      k += 12;
#560    case 12: c+=k[11];
#561    case 11: c+=((uint32_t)k[10])<<8;
#562    case 10: c+=((uint32_t)k[9])<<16;
#563    case 9 : c+=((uint32_t)k[8])<<24;
#564    case 8 : b+=k[7];
#565    case 7 : b+=((uint32_t)k[6])<<8;
#566    case 6 : b+=((uint32_t)k[5])<<16;
#567    case 5 : b+=((uint32_t)k[4])<<24;
#568    case 4 : a+=k[3];
#569    case 3 : a+=((uint32_t)k[2])<<8;
#570    case 2 : a+=((uint32_t)k[1])<<16;
#571    case 1 : a+=((uint32_t)k[0])<<24;
#620    const uint32_t *k = (const uint32_t *)key;         /* read 32-bit chunks */
#626      a += k[0];
#627      b += k[1];
#628      c += k[2];
#631      k += 3;
#648    case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
#649    case 11: c+=k[2]&0xffffffb+=k[1]; a+=k[0]; break;
#650    case 10: c+=k[2]&0xffffb+=k[1]; a+=k[0]; break;
#651    case 9 : c+=k[2]&0xffb+=k[1]; a+=k[0]; break;
#652    case 8 : b+=k[1]; a+=k[0]; break;
#653    case 7 : b+=k[1]&0xffffffa+=k[0]; break;
#654    case 6 : b+=k[1]&0xffffa+=k[0]; break;
#655    case 5 : b+=k[1]&0xffa+=k[0]; break;
#656    case 4 : a+=k[0]; break;
#657    case 3 : a+=k[0]&0xffffff; break;
#658    case 2 : a+=k[0]&0xffff; break;
#659    case 1 : a+=k[0]&0xff; break;
#665    k8 = (const uint8_t *)k;
#668    case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
#672    case 8 : b+=k[1]; a+=k[0]; break;
#676    case 4 : a+=k[0]; break;
#686    const uint16_t *k = (const uint16_t *)key;         /* read 16-bit chunks */
#692      a += k[0] + (((uint32_t)k[1])<<16);
#693      b += k[2] + (((uint32_t)k[3])<<16);
#694      c += k[4] + (((uint32_t)k[5])<<16);
#697      k += 6;
#701    k8 = (const uint8_t *)k;
#704    case 12: c+=k[4]+(((uint32_t)k[5])<<16);
#705             b+=k[2]+(((uint32_t)k[3])<<16);
#706             a+=k[0]+(((uint32_t)k[1])<<16);
#709    case 10: c+=k[4];
#710             b+=k[2]+(((uint32_t)k[3])<<16);
#711             a+=k[0]+(((uint32_t)k[1])<<16);
#714    case 8 : b+=k[2]+(((uint32_t)k[3])<<16);
#715             a+=k[0]+(((uint32_t)k[1])<<16);
#718    case 6 : b+=k[2];
#719             a+=k[0]+(((uint32_t)k[1])<<16);
#722    case 4 : a+=k[0]+(((uint32_t)k[1])<<16);
#725    case 2 : a+=k[0];
#733    const uint8_t *k = (const uint8_t *)key;
#738      a += k[0];
#739      a += ((uint32_t)k[1])<<8;
#740      a += ((uint32_t)k[2])<<16;
#741      a += ((uint32_t)k[3])<<24;
#742      b += k[4];
#743      b += ((uint32_t)k[5])<<8;
#744      b += ((uint32_t)k[6])<<16;
#745      b += ((uint32_t)k[7])<<24;
#746      c += k[8];
#747      c += ((uint32_t)k[9])<<8;
#748      c += ((uint32_t)k[10])<<16;
#749      c += ((uint32_t)k[11])<<24;
#752      k += 12;
#758    case 12: c+=((uint32_t)k[11])<<24;
#759    case 11: c+=((uint32_t)k[10])<<16;
#760    case 10: c+=((uint32_t)k[9])<<8;
#761    case 9 : c+=k[8];
#762    case 8 : b+=((uint32_t)k[7])<<24;
#763    case 7 : b+=((uint32_t)k[6])<<16;
#764    case 6 : b+=((uint32_t)k[5])<<8;
#765    case 5 : b+=k[4];
#766    case 4 : a+=((uint32_t)k[3])<<24;
#767    case 3 : a+=((uint32_t)k[2])<<16;
#768    case 2 : a+=((uint32_t)k[1])<<8;
#769    case 1 : a+=k[0];
#821  uint32_t c[HASHSTATE], d[HASHSTATE], i=0, j=0, klm=0, z;
#840   for (k=0; k<MAXPAIRk+=2)
#846     a[i] ^= (k<<j);
#847     a[i] ^= (k>>(8-j));
#849     b[i] ^= ((k+1)<<j);
#850     b[i] ^= ((k+1)>>(8-j));
#865   if (k>zz=k;
#866   if (k==MAXPAIR)
ncd2dispatch.c#779int k;
#780for(k=0;k<ncrank;k++) {
#781CDFnodedim = (CDFnode*)nclistget(vardims,k);
nclist.c#196    unsigned long i,j,k,len;
#205                for(k=j+1;k<len;k++) content[k-1] = content[k];
oc.c#27#define OCVERIFYX(k,x,r) if(!ocverify(x)||!ocverifyclass(x,k)) {return (r);}
#28#define OCVERIFY(k,xOCVERIFYX(k,x,OCTHROW(OC_EINVAL))
oclist.c#199    size_t i,j,k,len;
#208                for(k=j+1;k<len;k++) content[k-1] = content[k];
test_get.c#2045    int k;
#2120        for (k = 0; k < nslabsk++) {
#2123                if ((k >> j) & 1) {
#2201    int k;
#2276        for (k = 0; k < nslabsk++) {
#2279                if ((k >> j) & 1) {
#2357    int k;
#2432        for (k = 0; k < nslabsk++) {
#2435                if ((k >> j) & 1) {
#2513    int k;
#2588        for (k = 0; k < nslabsk++) {
#2591                if ((k >> j) & 1) {
#2669    int k;
#2744        for (k = 0; k < nslabsk++) {
#2747                if ((k >> j) & 1) {
#2825    int k;
#2900        for (k = 0; k < nslabsk++) {
#2903                if ((k >> j) & 1) {
#2981    int k;
#3056        for (k = 0; k < nslabsk++) {
#3059                if ((k >> j) & 1) {
#3137    int k;
#3212        for (k = 0; k < nslabsk++) {
#3215                if ((k >> j) & 1) {
#3293    int k;
#3368        for (k = 0; k < nslabsk++) {
#3371                if ((k >> j) & 1) {
#3449    int k;
#3524        for (k = 0; k < nslabsk++) {
#3527                if ((k >> j) & 1) {
#3605    int k;
#3680        for (k = 0; k < nslabsk++) {
#3683                if ((k >> j) & 1) {
#3761    int k;
#3836        for (k = 0; k < nslabsk++) {
#3839                if ((k >> j) & 1) {
#3920    int k;
#3990        for (k = 0; k < nslabsk++) {
#3993                if ((k >> j) & 1) {
#4094    int k;
#4164        for (k = 0; k < nslabsk++) {
#4167                if ((k >> j) & 1) {
#4268    int k;
#4338        for (k = 0; k < nslabsk++) {
#4341                if ((k >> j) & 1) {
#4442    int k;
#4512        for (k = 0; k < nslabsk++) {
#4515                if ((k >> j) & 1) {
#4616    int k;
#4686        for (k = 0; k < nslabsk++) {
#4689                if ((k >> j) & 1) {
#4790    int k;
#4860        for (k = 0; k < nslabsk++) {
#4863                if ((k >> j) & 1) {
#4964    int k;
#5034        for (k = 0; k < nslabsk++) {
#5037                if ((k >> j) & 1) {
#5138    int k;
#5208        for (k = 0; k < nslabsk++) {
#5211                if ((k >> j) & 1) {
#5312    int k;
#5382        for (k = 0; k < nslabsk++) {
#5385                if ((k >> j) & 1) {
#5486    int k;
#5556        for (k = 0; k < nslabsk++) {
#5559                if ((k >> j) & 1) {
#5660    int k;
#5730        for (k = 0; k < nslabsk++) {
#5733                if ((k >> j) & 1) {
#5834    int k;
#5904        for (k = 0; k < nslabsk++) {
#5907                if ((k >> j) & 1) {
#6011    int k;
#6083        for (k = 0; k < nslabsk++) {
#6086                if ((k >> j) & 1) {
#6193    int k;
#6265        for (k = 0; k < nslabsk++) {
#6268                if ((k >> j) & 1) {
#6375    int k;
#6447        for (k = 0; k < nslabsk++) {
#6450                if ((k >> j) & 1) {
#6557    int k;
#6629        for (k = 0; k < nslabsk++) {
#6632                if ((k >> j) & 1) {
#6739    int k;
#6811        for (k = 0; k < nslabsk++) {
#6814                if ((k >> j) & 1) {
#6921    int k;
#6993        for (k = 0; k < nslabsk++) {
#6996                if ((k >> j) & 1) {
#7103    int k;
#7175        for (k = 0; k < nslabsk++) {
#7178                if ((k >> j) & 1) {
#7285    int k;
#7357        for (k = 0; k < nslabsk++) {
#7360                if ((k >> j) & 1) {
#7467    int k;
#7539        for (k = 0; k < nslabsk++) {
#7542                if ((k >> j) & 1) {
#7649    int k;
#7721        for (k = 0; k < nslabsk++) {
#7724                if ((k >> j) & 1) {
#7831    int k;
#7903        for (k = 0; k < nslabsk++) {
#7906                if ((k >> j) & 1) {
#8013    int k;
#8085        for (k = 0; k < nslabsk++) {
#8088                if ((k >> j) & 1) {
#8197    size_t k;
#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)) {
#8226                    allInIntRange = allInIntRange && expect[k] >= text_min
#8227                                && expect[k] <= text_max;
#8246 for (k = 0; k < ATT_LEN(i,j); k++) {
#8247     if (inRange3(expect[k],ATT_TYPE(i,j),NCT_TEXT)
#8248                            && expect[k] >= text_min && expect[k] <= text_max) {
#8249 IF (!equal(value[k],expect[k],ATT_TYPE(i,j), NCT_TEXT)){
#8255                                error("element number: %d ", k);
#8256                                error("expect: %g", expect[k]);
#8257                                error("got: %g", (double) value[k]);
#8283    size_t k;
#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)) {
#8312                    allInIntRange = allInIntRange && expect[k] >= uchar_min
#8313                                && expect[k] <= uchar_max;
#8332 for (k = 0; k < ATT_LEN(i,j); k++) {
#8333     if (inRange3(expect[k],ATT_TYPE(i,j),NCT_UCHAR)
#8334                            && expect[k] >= uchar_min && expect[k] <= uchar_max) {
#8335 IF (!equal(value[k],expect[k],ATT_TYPE(i,j), NCT_UCHAR)){
#8341                                error("element number: %d ", k);
#8342                                error("expect: %g", expect[k]);
#8343                                error("got: %g", (double) value[k]);
#8369    size_t k;
#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)) {
#8398                    allInIntRange = allInIntRange && expect[k] >= schar_min
#8399                                && expect[k] <= schar_max;
#8418 for (k = 0; k < ATT_LEN(i,j); k++) {
#8419     if (inRange3(expect[k],ATT_TYPE(i,j),NCT_SCHAR)
#8420                            && expect[k] >= schar_min && expect[k] <= schar_max) {
#8421 IF (!equal(value[k],expect[k],ATT_TYPE(i,j), NCT_SCHAR)){
#8427                                error("element number: %d ", k);
#8428                                error("expect: %g", expect[k]);
#8429                                error("got: %g", (double) value[k]);
#8455    size_t k;
#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)) {
#8484                    allInIntRange = allInIntRange && expect[k] >= short_min
#8485                                && expect[k] <= short_max;
#8504 for (k = 0; k < ATT_LEN(i,j); k++) {
#8505     if (inRange3(expect[k],ATT_TYPE(i,j),NCT_SHORT)
#8506                            && expect[k] >= short_min && expect[k] <= short_max) {
#8507 IF (!equal(value[k],expect[k],ATT_TYPE(i,j), NCT_SHORT)){
#8513                                error("element number: %d ", k);
#8514                                error("expect: %g", expect[k]);
#8515                                error("got: %g", (double) value[k]);
#8541    size_t k;
#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)) {
#8570                    allInIntRange = allInIntRange && expect[k] >= int_min
#8571                                && expect[k] <= int_max;
#8590 for (k = 0; k < ATT_LEN(i,j); k++) {
#8591     if (inRange3(expect[k],ATT_TYPE(i,j),NCT_INT)
#8592                            && expect[k] >= int_min && expect[k] <= int_max) {
#8593 IF (!equal(value[k],expect[k],ATT_TYPE(i,j), NCT_INT)){
#8599                                error("element number: %d ", k);
#8600                                error("expect: %g", expect[k]);
#8601                                error("got: %g", (double) value[k]);
#8627    size_t k;
#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)) {
#8656                    allInIntRange = allInIntRange && expect[k] >= long_min
#8657                                && expect[k] <= long_max;
#8676 for (k = 0; k < ATT_LEN(i,j); k++) {
#8677     if (inRange3(expect[k],ATT_TYPE(i,j),NCT_LONG)
#8678                            && expect[k] >= long_min && expect[k] <= long_max) {
#8679 IF (!equal(value[k],expect[k],ATT_TYPE(i,j), NCT_LONG)){
#8685                                error("element number: %d ", k);
#8686                                error("expect: %g", expect[k]);
#8687                                error("got: %g", (double) value[k]);
#8713    size_t k;
#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)) {
#8742                    allInIntRange = allInIntRange && expect[k] >= float_min
#8743                                && expect[k] <= float_max;
#8762 for (k = 0; k < ATT_LEN(i,j); k++) {
#8763     if (inRange3(expect[k],ATT_TYPE(i,j),NCT_FLOAT)
#8764                            && expect[k] >= float_min && expect[k] <= float_max) {
#8765 IF (!equal(value[k],expect[k],ATT_TYPE(i,j), NCT_FLOAT)){
#8771                                error("element number: %d ", k);
#8772                                error("expect: %g", expect[k]);
#8773                                error("got: %g", (double) value[k]);
#8799    size_t k;
#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)) {
#8828                    allInIntRange = allInIntRange && expect[k] >= double_min
#8829                                && expect[k] <= double_max;
#8848 for (k = 0; k < ATT_LEN(i,j); k++) {
#8849     if (inRange3(expect[k],ATT_TYPE(i,j),NCT_DOUBLE)
#8850                            && expect[k] >= double_min && expect[k] <= double_max) {
#8851 IF (!equal(value[k],expect[k],ATT_TYPE(i,j), NCT_DOUBLE)){
#8857                                error("element number: %d ", k);
#8858                                error("expect: %g", expect[k]);
#8859                                error("got: %g", (double) value[k]);
#8885    size_t k;
#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)) {
#8914                    allInIntRange = allInIntRange && expect[k] >= ushort_min
#8915                                && expect[k] <= ushort_max;
#8934 for (k = 0; k < ATT_LEN(i,j); k++) {
#8935     if (inRange3(expect[k],ATT_TYPE(i,j),NCT_USHORT)
#8936                            && expect[k] >= ushort_min && expect[k] <= ushort_max) {
#8937 IF (!equal(value[k],expect[k],ATT_TYPE(i,j), NCT_USHORT)){
#8943                                error("element number: %d ", k);
#8944                                error("expect: %g", expect[k]);
#8945                                error("got: %g", (double) value[k]);
#8971    size_t k;
#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)) {
#9000                    allInIntRange = allInIntRange && expect[k] >= uint_min
#9001                                && expect[k] <= uint_max;
#9020 for (k = 0; k < ATT_LEN(i,j); k++) {
#9021     if (inRange3(expect[k],ATT_TYPE(i,j),NCT_UINT)
#9022                            && expect[k] >= uint_min && expect[k] <= uint_max) {
#9023 IF (!equal(value[k],expect[k],ATT_TYPE(i,j), NCT_UINT)){
#9029                                error("element number: %d ", k);
#9030                                error("expect: %g", expect[k]);
#9031                                error("got: %g", (double) value[k]);
#9057    size_t k;
#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)) {
#9086                    allInIntRange = allInIntRange && expect[k] >= longlong_min
#9087                                && expect[k] <= longlong_max;
#9106 for (k = 0; k < ATT_LEN(i,j); k++) {
#9107     if (inRange3(expect[k],ATT_TYPE(i,j),NCT_LONGLONG)
#9108                            && expect[k] >= longlong_min && expect[k] <= longlong_max) {
#9109 IF (!equal(value[k],expect[k],ATT_TYPE(i,j), NCT_LONGLONG)){
#9115                                error("element number: %d ", k);
#9116                                error("expect: %g", expect[k]);
#9117                                error("got: %g", (double) value[k]);
#9143    size_t k;
#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)) {
#9172                    allInIntRange = allInIntRange && expect[k] >= ulonglong_min
#9173                                && expect[k] <= ulonglong_max;
#9192 for (k = 0; k < ATT_LEN(i,j); k++) {
#9193     if (inRange3(expect[k],ATT_TYPE(i,j),NCT_ULONGLONG)
#9194                            && expect[k] >= ulonglong_min && expect[k] <= ulonglong_max) {
#9195 IF (!equal(value[k],expect[k],ATT_TYPE(i,j), NCT_ULONGLONG)){
#9201                                error("element number: %d ", k);
#9202                                error("expect: %g", expect[k]);
#9203                                error("got: %g", (double) value[k]);
test_put.c#1245    size_t  k;
#1268 for (k = 0; k < lengthk++) {
#1269     expect[k] = hash4datatype, -1, &kNCT_TEXT);
#1270     if (inRange3(expect[k], datatypeNCT_TEXT)) {
#1272 if (expect[k] >= text_min && expect[k] <= text_max)
#1284 for (k = 0; k < lengthk++) {
#1285                    if (inRange3(expect[k],datatype,NCT_TEXT)
#1286                            && expect[k] >= text_min && expect[k] <= text_max) {
#1287                        IF (!equal(value[k],expect[k],datatype,NCT_TEXT)) {
#1293                                error("element number: %d ", k);
#1294                                error("expect: %g, ", expect[k]);
#1295                                error("got: %g", (double) value[k]);
#1320    size_t  k;
#1343 for (k = 0; k < lengthk++) {
#1344     expect[k] = hash4datatype, -1, &kNCT_UCHAR);
#1345     if (inRange3(expect[k], datatypeNCT_UCHAR)) {
#1347 if (expect[k] >= uchar_min && expect[k] <= uchar_max)
#1359 for (k = 0; k < lengthk++) {
#1360                    if (inRange3(expect[k],datatype,NCT_UCHAR)
#1361                            && expect[k] >= uchar_min && expect[k] <= uchar_max) {
#1362                        IF (!equal(value[k],expect[k],datatype,NCT_UCHAR)) {
#1368                                error("element number: %d ", k);
#1369                                error("expect: %g, ", expect[k]);
#1370                                error("got: %g", (double) value[k]);
#1395    size_t  k;
#1418 for (k = 0; k < lengthk++) {
#1419     expect[k] = hash4datatype, -1, &kNCT_SCHAR);
#1420     if (inRange3(expect[k], datatypeNCT_SCHAR)) {
#1422 if (expect[k] >= schar_min && expect[k] <= schar_max)
#1434 for (k = 0; k < lengthk++) {
#1435                    if (inRange3(expect[k],datatype,NCT_SCHAR)
#1436                            && expect[k] >= schar_min && expect[k] <= schar_max) {
#1437                        IF (!equal(value[k],expect[k],datatype,NCT_SCHAR)) {
#1443                                error("element number: %d ", k);
#1444                                error("expect: %g, ", expect[k]);
#1445                                error("got: %g", (double) value[k]);
#1470    size_t  k;
#1493 for (k = 0; k < lengthk++) {
#1494     expect[k] = hash4datatype, -1, &kNCT_SHORT);
#1495     if (inRange3(expect[k], datatypeNCT_SHORT)) {
#1497 if (expect[k] >= short_min && expect[k] <= short_max)
#1509 for (k = 0; k < lengthk++) {
#1510                    if (inRange3(expect[k],datatype,NCT_SHORT)
#1511                            && expect[k] >= short_min && expect[k] <= short_max) {
#1512                        IF (!equal(value[k],expect[k],datatype,NCT_SHORT)) {
#1518                                error("element number: %d ", k);
#1519                                error("expect: %g, ", expect[k]);
#1520                                error("got: %g", (double) value[k]);
#1545    size_t  k;
#1568 for (k = 0; k < lengthk++) {
#1569     expect[k] = hash4datatype, -1, &kNCT_INT);
#1570     if (inRange3(expect[k], datatypeNCT_INT)) {
#1572 if (expect[k] >= int_min && expect[k] <= int_max)
#1584 for (k = 0; k < lengthk++) {
#1585                    if (inRange3(expect[k],datatype,NCT_INT)
#1586                            && expect[k] >= int_min && expect[k] <= int_max) {
#1587                        IF (!equal(value[k],expect[k],datatype,NCT_INT)) {
#1593                                error("element number: %d ", k);
#1594                                error("expect: %g, ", expect[k]);
#1595                                error("got: %g", (double) value[k]);
#1620    size_t  k;
#1643 for (k = 0; k < lengthk++) {
#1644     expect[k] = hash4datatype, -1, &kNCT_LONG);
#1645     if (inRange3(expect[k], datatypeNCT_LONG)) {
#1647 if (expect[k] >= long_min && expect[k] <= long_max)
#1659 for (k = 0; k < lengthk++) {
#1660                    if (inRange3(expect[k],datatype,NCT_LONG)
#1661                            && expect[k] >= long_min && expect[k] <= long_max) {
#1662                        IF (!equal(value[k],expect[k],datatype,NCT_LONG)) {
#1668                                error("element number: %d ", k);
#1669                                error("expect: %g, ", expect[k]);
#1670                                error("got: %g", (double) value[k]);
#1695    size_t  k;
#1718 for (k = 0; k < lengthk++) {
#1719     expect[k] = hash4datatype, -1, &kNCT_FLOAT);
#1720     if (inRange3(expect[k], datatypeNCT_FLOAT)) {
#1722 if (expect[k] >= float_min && expect[k] <= float_max)
#1734 for (k = 0; k < lengthk++) {
#1735                    if (inRange3(expect[k],datatype,NCT_FLOAT)
#1736                            && expect[k] >= float_min && expect[k] <= float_max) {
#1737                        IF (!equal(value[k],expect[k],datatype,NCT_FLOAT)) {
#1743                                error("element number: %d ", k);
#1744                                error("expect: %g, ", expect[k]);
#1745                                error("got: %g", (double) value[k]);
#1770    size_t  k;
#1793 for (k = 0; k < lengthk++) {
#1794     expect[k] = hash4datatype, -1, &kNCT_DOUBLE);
#1795     if (inRange3(expect[k], datatypeNCT_DOUBLE)) {
#1797 if (expect[k] >= double_min && expect[k] <= double_max)
#1809 for (k = 0; k < lengthk++) {
#1810                    if (inRange3(expect[k],datatype,NCT_DOUBLE)
#1811                            && expect[k] >= double_min && expect[k] <= double_max) {
#1812                        IF (!equal(value[k],expect[k],datatype,NCT_DOUBLE)) {
#1818                                error("element number: %d ", k);
#1819                                error("expect: %g, ", expect[k]);
#1820                                error("got: %g", (double) value[k]);
#1845    size_t  k;
#1868 for (k = 0; k < lengthk++) {
#1869     expect[k] = hash4datatype, -1, &kNCT_USHORT);
#1870     if (inRange3(expect[k], datatypeNCT_USHORT)) {
#1872 if (expect[k] >= ushort_min && expect[k] <= ushort_max)
#1884 for (k = 0; k < lengthk++) {
#1885                    if (inRange3(expect[k],datatype,NCT_USHORT)
#1886                            && expect[k] >= ushort_min && expect[k] <= ushort_max) {
#1887                        IF (!equal(value[k],expect[k],datatype,NCT_USHORT)) {
#1893                                error("element number: %d ", k);
#1894                                error("expect: %g, ", expect[k]);
#1895                                error("got: %g", (double) value[k]);
#1920    size_t  k;
#1943 for (k = 0; k < lengthk++) {
#1944     expect[k] = hash4datatype, -1, &kNCT_UINT);
#1945     if (inRange3(expect[k], datatypeNCT_UINT)) {
#1947 if (expect[k] >= uint_min && expect[k] <= uint_max)
#1959 for (k = 0; k < lengthk++) {
#1960                    if (inRange3(expect[k],datatype,NCT_UINT)
#1961                            && expect[k] >= uint_min && expect[k] <= uint_max) {
#1962                        IF (!equal(value[k],expect[k],datatype,NCT_UINT)) {
#1968                                error("element number: %d ", k);
#1969                                error("expect: %g, ", expect[k]);
#1970                                error("got: %g", (double) value[k]);
#1995    size_t  k;
#2018 for (k = 0; k < lengthk++) {
#2019     expect[k] = hash4datatype, -1, &kNCT_LONGLONG);
#2020     if (inRange3(expect[k], datatypeNCT_LONGLONG)) {
#2022 if (expect[k] >= longlong_min && expect[k] <= longlong_max)
#2034 for (k = 0; k < lengthk++) {
#2035                    if (inRange3(expect[k],datatype,NCT_LONGLONG)
#2036                            && expect[k] >= longlong_min && expect[k] <= longlong_max) {
#2037                        IF (!equal(value[k],expect[k],datatype,NCT_LONGLONG)) {
#2043                                error("element number: %d ", k);
#2044                                error("expect: %g, ", expect[k]);
#2045                                error("got: %g", (double) value[k]);
#2070    size_t  k;
#2093 for (k = 0; k < lengthk++) {
#2094     expect[k] = hash4datatype, -1, &kNCT_ULONGLONG);
#2095     if (inRange3(expect[k], datatypeNCT_ULONGLONG)) {
#2097 if (expect[k] >= ulonglong_min && expect[k] <= ulonglong_max)
#2109 for (k = 0; k < lengthk++) {
#2110                    if (inRange3(expect[k],datatype,NCT_ULONGLONG)
#2111                            && expect[k] >= ulonglong_min && expect[k] <= ulonglong_max) {
#2112                        IF (!equal(value[k],expect[k],datatype,NCT_ULONGLONG)) {
#2118                                error("element number: %d ", k);
#2119                                error("expect: %g, ", expect[k]);
#2120                                error("got: %g", (double) value[k]);
#4922    int k;
#5014 for (k = 0; k < nslabsk++) {
#5017 if ((k >> j) & 1) {
#5073    int k;
#5165 for (k = 0; k < nslabsk++) {
#5168 if ((k >> j) & 1) {
#5224    int k;
#5316 for (k = 0; k < nslabsk++) {
#5319 if ((k >> j) & 1) {
#5375    int k;
#5467 for (k = 0; k < nslabsk++) {
#5470 if ((k >> j) & 1) {
#5526    int k;
#5618 for (k = 0; k < nslabsk++) {
#5621 if ((k >> j) & 1) {
#5677    int k;
#5769 for (k = 0; k < nslabsk++) {
#5772 if ((k >> j) & 1) {
#5828    int k;
#5920 for (k = 0; k < nslabsk++) {
#5923 if ((k >> j) & 1) {
#5979    int k;
#6071 for (k = 0; k < nslabsk++) {
#6074 if ((k >> j) & 1) {
#6130    int k;
#6222 for (k = 0; k < nslabsk++) {
#6225 if ((k >> j) & 1) {
#6281    int k;
#6373 for (k = 0; k < nslabsk++) {
#6376 if ((k >> j) & 1) {
#6432    int k;
#6524 for (k = 0; k < nslabsk++) {
#6527 if ((k >> j) & 1) {
#6583    int k;
#6675 for (k = 0; k < nslabsk++) {
#6678 if ((k >> j) & 1) {
#6737    int k;
#6828 for (k = 0; k < nslabsk++) {
#6831 if ((k >> j) & 1) {
#6909    int k;
#7000 for (k = 0; k < nslabsk++) {
#7003 if ((k >> j) & 1) {
#7081    int k;
#7172 for (k = 0; k < nslabsk++) {
#7175 if ((k >> j) & 1) {
#7253    int k;
#7344 for (k = 0; k < nslabsk++) {
#7347 if ((k >> j) & 1) {
#7425    int k;
#7516 for (k = 0; k < nslabsk++) {
#7519 if ((k >> j) & 1) {
#7597    int k;
#7688 for (k = 0; k < nslabsk++) {
#7691 if ((k >> j) & 1) {
#7769    int k;
#7860 for (k = 0; k < nslabsk++) {
#7863 if ((k >> j) & 1) {
#7941    int k;
#8032 for (k = 0; k < nslabsk++) {
#8035 if ((k >> j) & 1) {
#8113    int k;
#8204 for (k = 0; k < nslabsk++) {
#8207 if ((k >> j) & 1) {
#8285    int k;
#8376 for (k = 0; k < nslabsk++) {
#8379 if ((k >> j) & 1) {
#8457    int k;
#8548 for (k = 0; k < nslabsk++) {
#8551 if ((k >> j) & 1) {
#8629    int k;
#8720 for (k = 0; k < nslabsk++) {
#8723 if ((k >> j) & 1) {
#8804    int k;
#8897 for (k = 0; k < nslabsk++) {
#8900 if ((k >> j) & 1) {
#8984    int k;
#9077 for (k = 0; k < nslabsk++) {
#9080 if ((k >> j) & 1) {
#9164    int k;
#9257 for (k = 0; k < nslabsk++) {
#9260 if ((k >> j) & 1) {
#9344    int k;
#9437 for (k = 0; k < nslabsk++) {
#9440 if ((k >> j) & 1) {
#9524    int k;
#9617 for (k = 0; k < nslabsk++) {
#9620 if ((k >> j) & 1) {
#9704    int k;
#9797 for (k = 0; k < nslabsk++) {
#9800 if ((k >> j) & 1) {
#9884    int k;
#9977 for (k = 0; k < nslabsk++) {
#9980 if ((k >> j) & 1) {
#10064    int k;
#10157 for (k = 0; k < nslabsk++) {
#10160 if ((k >> j) & 1) {
#10244    int k;
#10337 for (k = 0; k < nslabsk++) {
#10340 if ((k >> j) & 1) {
#10424    int k;
#10517 for (k = 0; k < nslabsk++) {
#10520 if ((k >> j) & 1) {
#10604    int k;
#10697 for (k = 0; k < nslabsk++) {
#10700 if ((k >> j) & 1) {
#10784    int k;
#10877 for (k = 0; k < nslabsk++) {
#10880 if ((k >> j) & 1) {
#10965    size_t k;
#10997 for (k = 0; k < ATT_LEN(i,j); k++) {
#10998     value[k] = hash(ATT_TYPE(i,j), -1, &k);
#11027    size_t k;
#11056 for (allInExtRange = 1, k = 0; k < ATT_LEN(i,j); k++) {
#11057     value[k] = hash_uchar(ATT_TYPE(i,j), -1, &kNCT_UCHAR);
#11059 && inRange3(value[k], ATT_TYPE(i,j), NCT_UCHAR);
#11090    size_t k;
#11119 for (allInExtRange = 1, k = 0; k < ATT_LEN(i,j); k++) {
#11120     value[k] = hash_schar(ATT_TYPE(i,j), -1, &kNCT_SCHAR);
#11122 && inRange3(value[k], ATT_TYPE(i,j), NCT_SCHAR);
#11153    size_t k;
#11182 for (allInExtRange = 1, k = 0; k < ATT_LEN(i,j); k++) {
#11183     value[k] = hash_short(ATT_TYPE(i,j), -1, &kNCT_SHORT);
#11185 && inRange3(value[k], ATT_TYPE(i,j), NCT_SHORT);
#11216    size_t k;
#11245 for (allInExtRange = 1, k = 0; k < ATT_LEN(i,j); k++) {
#11246     value[k] = hash_int(ATT_TYPE(i,j), -1, &kNCT_INT);
#11248 && inRange3(value[k], ATT_TYPE(i,j), NCT_INT);
#11279    size_t k;
#11308 for (allInExtRange = 1, k = 0; k < ATT_LEN(i,j); k++) {
#11309     value[k] = hash_long(ATT_TYPE(i,j), -1, &kNCT_LONG);
#11311 && inRange3(value[k], ATT_TYPE(i,j), NCT_LONG);
#11342    size_t k;
#11371 for (allInExtRange = 1, k = 0; k < ATT_LEN(i,j); k++) {
#11372     value[k] = hash_float(ATT_TYPE(i,j), -1, &kNCT_FLOAT);
#11374 && inRange3(value[k], ATT_TYPE(i,j), NCT_FLOAT);
#11405    size_t k;
#11434 for (allInExtRange = 1, k = 0; k < ATT_LEN(i,j); k++) {
#11435     value[k] = hash_double(ATT_TYPE(i,j), -1, &kNCT_DOUBLE);
#11437 && inRange3(value[k], ATT_TYPE(i,j), NCT_DOUBLE);
#11468    size_t k;
#11497 for (allInExtRange = 1, k = 0; k < ATT_LEN(i,j); k++) {
#11498     value[k] = hash_ushort(ATT_TYPE(i,j), -1, &kNCT_USHORT);
#11500 && inRange3(value[k], ATT_TYPE(i,j), NCT_USHORT);
#11531    size_t k;
#11560 for (allInExtRange = 1, k = 0; k < ATT_LEN(i,j); k++) {
#11561     value[k] = hash_uint(ATT_TYPE(i,j), -1, &kNCT_UINT);
#11563 && inRange3(value[k], ATT_TYPE(i,j), NCT_UINT);
#11594    size_t k;
#11623 for (allInExtRange = 1, k = 0; k < ATT_LEN(i,j); k++) {
#11624     value[k] = hash_longlong(ATT_TYPE(i,j), -1, &kNCT_LONGLONG);
#11626 && inRange3(value[k], ATT_TYPE(i,j), NCT_LONGLONG);
#11657    size_t k;
#11686 for (allInExtRange = 1, k = 0; k < ATT_LEN(i,j); k++) {
#11687     value[k] = hash_ulonglong(ATT_TYPE(i,j), -1, &kNCT_ULONGLONG);
#11689 && inRange3(value[k], ATT_TYPE(i,j), NCT_ULONGLONG);
test_read.c#907    int k;
#957        for (k = 0; k < nslabsk++) {
#960                if ((k >> j) & 1) {
#1027    int k;
#1092        for (k = 0; k < nslabsk++) {
#1095                if ((k >> j) & 1) {
#1195    int k;
#1265        for (k = 0; k < nslabsk++) {
#1268                if ((k >> j) & 1) {
#1347    size_t k;
#1374 for (k = 0; k < ATT_LEN(i,j); k++) {
#1375     expect = hash(ATT_TYPE(i,j), -1, &k );
#1377     p += k * nctypelen(ATT_TYPE(i,j));
#1390 error("element number: %d\n", k);
test_write.c#793    int k;
#851        for (k = 0; k < nslabsk++) {
#854                if ((k >> j) & 1) {
#914    int k;
#985        for (k = 0; k < nslabsk++) {
#988                if ((k >> j) & 1) {
#1069    int k;
#1160        for (k = 0; k < nslabsk++) {
#1163                if ((k >> j) & 1) {
#1305    size_t k;
#1341     for (k = 0; k < lengthk++) {
#1342 value = hash(datatype, -1, &k );
#1529    size_t  k;
#1611                for (k = 0; k < attlengthk++) {
#1612                    expect = hash(datatype, -1, &k);
#1613                    IF (text[k] != expect) {
#1623                for (k = 0; k < attlengthk++) {
#1624                    expect = hash(datatype, -1, &k);
#1626 IF (!equal(value[k],expect,datatype,NCT_DOUBLE)) {
tst_big_var6.c#52    int ijk;
tst_chunks3.c#158    int ijk;
#226 for(k = 0; k < dims[2]; k++) {
#227     varyz[mm++] = k + dims[2]*j;
#232 for(k = 0; k < dims[2]; k++) {
#233     varxz[mm++] = k + dims[2]*i;
tst_comp2.c#33   int ijk;
#153   for (k = 0; k < DIM_LENk++) {
#155       index[0] = k;
#157       if (val_in.dow != data[k].dowERR;
#159    if (val_in.mon[i] != data[k].mon[i]) ERR;
#162    if (val_in.vec[i] != data[k].vec[i]) ERR;
#166        if (val_in.mat[i][j] != data[k].mat[i][j]) ERR;
tst_dims.c#853      int ijkl;
#858     for (k = 0; k < LEVEL_LENk++)
#860   pres[i][j][k][l] = 1013.1 + j;
#996     for (k = 0; k < LEVEL_LENk++)
#998   if (0 != pres_in[i][j][k][l]) ERR;
#1030     for (k = 0; k < LEVEL_LENk++)
#1032   if (pres[i][j][k][l] != pres_in[i][j][k][l]) ERR;
tst_h_atts3.c#64      int ijk;
#73     for (k = 0; k < cvc_out[i].data[j].lenk++)
#75        ((struct s1 *)cvc_out[i].data[j].p)[k].x = 42.42;
#76        ((struct s1 *)cvc_out[i].data[j].p)[k].y = 2.0;
#209      int ik;
#217  for (k = 0; k < vc_out[i].lenk++)
#218     ((int *)vc_out[i].p)[k] = 42;
tst_h_atts4.c#64      int ik;
#73  for (k = 0; k < vc_out[i].lenk++)
#75     ((struct s1 *)vc_out[i].p)[k].x = 42.42;
#76     ((struct s1 *)vc_out[i].p)[k].y = 2.0;
tst_h_files.c#36      int jk;
#43  for (k = 0; k < OPAQUE_SIZEk++)
#44     data[j][k] = 42;
tst_h_files2.c#29      int jk;
#33  for (k = 0; k < OPAQUE_SIZEk++)
#34     data[j][k] = 42;
tst_nc4perf.c#150   int kjit;
#156   for(k = 0; k < DIMSIZE3k++)
#160     *tempudata = (float)(1 + mpi_rank) * 2 * (j + 1) * (k + 1);
tst_parallel3.c#185   unsigned m,k,j,i;
#280      for( k=0; k<ucount[1];k++)
#284        *tempudata = (1+mpi_rank)*2*(j+1)*(k+1)*(m+1);
#358          for(k = 0; k < ucount[1]; k++)
#362                   if(*temprudata != (1+mpi_rank)*2*(j+1)*(k+1)*(m+1))
tst_special_atts.c#42   int ijkm;
#146    for(k = 0; k < DIM3_LENk++) {
#147        data3[i][j][k] = m++;
#192    for(k = 0; k < DIM3_LENk++)
#193        if(data3_in[i][j][k] != data3[i][j][k]) ERR;
#198    for(k = 0; k < DIM3_LENk++)
#199        if(data3_in[i][j][k] != data3[i][j][k]) ERR;
tst_varms.c#41   int ijk = 0;
#52     data_2d[i][j] = k++;
#104      k = 0;
#107     data[i][j] = k++;
#167     for (k = 0; k < D2k++)
#168        data[i][j][k] = i + j + k;
#187     for (k = 0; k < D2k++)
#188        if (data_in[i][j][k] != data[i][j][k]) ERR;
#196     for (k = 0; k < D2k++)
#197        if (data_in[i][j][k] != data[i][j][k]) ERR;
#223      int k=0;
#229     data[i][j] = k;
#230     data_in[j][i] = k;
#231     k++;
tst_xplatform2.c#173   int ijk;
#213  for (k = 0; k < data_out[i].data[j].lenk++)
#214     if (((struct s1 *)data_in[i].data[j].p)[k].x != ((struct s1 *)data_out[i].data[j].p)[k].x ||
#215 ((struct s1 *)data_in[i].data[j].p)[k].y != ((struct s1 *)data_out[i].data[j].p)[k].yERR;
#237   int ijk;
#277  for (k = 0; k < data_out[i].data[j].lenk++)
#278     if (((struct s1 *)data_in[i].data[j].p)[k].x != ((struct s1 *)data_out[i].data[j].p)[k].x ||
#279 ((struct s1 *)data_in[i].data[j].p)[k].y != ((struct s1 *)data_out[i].data[j].p)[k].yERR;
#295   int ijk;
#336  for (k = 0; k < comp_array_of_vlen_of_comp_out[i].data[j].lenk++)
#338     ((struct s1 *)comp_array_of_vlen_of_comp_out[i].data[j].p)[k].x = 42.42;
#339     ((struct s1 *)comp_array_of_vlen_of_comp_out[i].data[j].p)[k].y = 2.0;
util.c#780    size_t  k;
#789 for (k = 0; k < ATT_LEN(i,j); k++) {
#790     catt[k] = hash(ATT_TYPE(i,j), -1, &k);
#797 for (allInRange = 1, k = 0; k < ATT_LEN(i,j); k++) {
#798     att[k] = hash(ATT_TYPE(i,j), -1, &k);
#799     allInRange = allInRange && inRange(att[k], ATT_TYPE(i,j));
#1014    size_t  k;
#1041 for (k = 0; k < ATT_LEN(i,j); k++) {
#1042     IF (text[k] != hash(datatype, -1, &k)) {
#1050 for (k = 0; k < ATT_LEN(i,j); k++) {
#1051     expect = hash(datatype, -1, &k);
#1055 IF (!equal(value[k], expectATT_TYPE(i,j), NCT_DOUBLE)) {


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