bytebuffer.c#95bbGet(Bytebufferbb, unsigned int index)
#98  if(index >= bb->length) return -1;
#99  return bb->content[index];
#103bbSet(Bytebufferbb, unsigned int index, char elem)
#106  if(index >= bb->length) return bbFail();
#107  bb->content[index] = elem;
#160bbInsert(Bytebufferbb, const unsigned int index, const char elem)
#164  return bbInsertn(bb,index,tmp,1);
#168bbInsertn(Bytebufferbb, const unsigned int index, const char* elem, const unsigned int n)
#195  for(j=newlen-1,i=index;i<bb->length;i++) {
#198  memcpy((void*)(bb->content+index),(void*)elem,n);
cache.c#27    int i,j,found,index;
#50    index = 0;
#60            if(var == target) {found=1;index=i;break;}
#69     nclistremove(cache->nodes,index);
cdf.c#438    int indexijmatch;
#450    for(index=0;index<nclistlength(dxdparent->subnodes);index++) {
#451        CDFnodedxdsubnode = (CDFnode*)nclistget(dxdparent->subnodes,index);
#511 int index = findin(node->container,node);
#513 ncstat = structwrap(nccnode,node->container,index,
dapalign.c#97    int index = 0;
#100      case NC_BYTE:   index = NCCTYPEUCHAR; break;
#101      case NC_CHAR:   index = NCCTYPECHAR; break;
#102      case NC_SHORT:  index = NCCTYPESHORT; break;
#103      case NC_INT:    index = NCCTYPEINT; break;
#104      case NC_FLOAT:  index = NCCTYPEFLOAT; break;
#105      case NC_DOUBLEindex = NCCTYPEDOUBLE; break;
#106      case NC_UBYTE:  index = NCCTYPEUCHAR; break;
#107      case NC_USHORTindex = NCCTYPEUSHORT; break;
#108      case NC_UINT:   index = NCCTYPEUINT; break;
#109      case NC_INT64:  index = NCCTYPELONGLONG; break;
#110      case NC_UINT64index = NCCTYPEULONGLONG; break;
#111      case NC_STRINGindex = NCCTYPEPTR; break;
#112      case NC_VLEN:   index = NCCTYPENCVLEN; break;
#113      case NC_OPAQUEindex = NCCTYPEUCHAR; break;
#121    align = &vec[index];
dapdump.c#152dumpdata1(nc_type nctype, size_t index, char* data)
#156 fprintf(stdout,"'%c' %hhd",data[index],data[index]);
#159 fprintf(stdout,"%hdB",((signed char*)data)[index]);
#162 fprintf(stdout,"%huB",((unsigned char*)data)[index]);
#165 fprintf(stdout,"%hdS",((short*)data)[index]);
#168 fprintf(stdout,"%hdUS",((unsigned short*)data)[index]);
#171 fprintf(stdout,"%d",((int*)data)[index]);
#174 fprintf(stdout,"%uU",((unsigned int*)data)[index]);
#177 fprintf(stdout,"%#gF",((float*)data)[index]);
#180 fprintf(stdout,"%#gD",((double*)data)[index]);
#183 fprintf(stdout,"\"%s\"",((char**)data)[index]);
dapdump.h#42extern void dumpdata1(nc_type nctype, size_t index, char* data);
#55extern void dumpdata1(nc_type nctype, size_t index, char* data);
dapodom.c#35 odom->index[i] = odom->start[i];
#62 odom->index[i] = odom->start[i];
#85 (size_t)odom->index[i],
#98    return (odom->index[0] < odom->stop[0]);
#109 offset += odom->index[i];
#120        odom->index[i] += odom->stride[i];
#121        if(odom->index[i] < odom->stop[i]) break;
#123 odom->index[i] = odom->start[i]; /* reset this position*/
#136 tmp = odom->index[i];
dapodom.h#11    size_t         index[NC_MAX_VAR_DIMS];
dapparse.c#256dimnameanon(char* basename, unsigned int index)
#259    sprintf(name,"%s_%d",basename,index);
dapparselex.h#88extern char* dimnameanon(char* basename, unsigned int index);
data.c#89    src->index = 0;
#102    src->index = 0;
#115    src->index = 0;
#149    if(ds->index < ds->length)
#150 return &ds->data[ds->index];
#159    ds->index = 0;
#167    if(ds->index < ds->length)
#168 return &ds->data[ds->index++];
#180    if(ds->index < ds->length) return 1;
#188    int index = ds->index;
#192    if(index >= lenindex = len-1;
#193    return ds->data[index].lineno;
#214    src->index = 0;
#241    if(ds->index >= ds->lengthPANIC("srcsetfill: no space");
#242    if(ds->data[ds->index].nctype != NC_FILLVALUEPANIC("srcsetfill: not fill");
#243    ds->data[ds->index].nctype = NC_COMPOUND;
#244    ds->data[ds->index].value.compoundv = list;
#262report0(char* leadDatasrcsrc, int index)
#334datalistreplace(Datalistdl, unsigned int indexNCConstantcon)
#337    ASSERT(index < dl->length);
#339    dl->data[index] = *con;
data.h#79    int index;
#162#define srcpeek(ds) ((ds)==NULL || (ds)->index >= (ds)->max?NULL:(ds)->data+(ds)->index)
dceparse.c#190indexpath(DCEparsestatestateObject list0Object index)
#192    return collectlist(list0,index);
dceparselex.h#74extern Object arrayelement(DCEparsestatestateObject nameObject index);
#81extern Object indexpath(DCEparsestatestateObject list0Object index);
dump.c#264    int icountindexdepth;
#267    index = src->index;
#269    if(index > countindex = count;
#272        fprintf(stderr,"[%d/%d]",src->index,src->length);
#273 for(i=0;i<index;i++) {
#278 for(i=index;i<count;i++) {
dv2i.c#681    const long* index,
#686 A_DECL(coordp, size_t, (size_t)ndimsindex);
#687 A_INIT(coordp, size_t, (size_t)ndimsindex);
#705    const long* index,
#710 A_DECL(coordp, size_t, ndimsindex);
#711 A_INIT(coordp, size_t, ndimsindex);
dvarget.c#20    size_t         index[NC_MAX_VAR_DIMS];
#45 odom->index[i] = odom->start[i];
#55    return (odom->index[0] < odom->stop[0]);
#67        odom->index[i] += (size_t)odom->stride[i];
#68        if(odom->index[i] < odom->stop[i]) break;
#70 odom->index[i] = odom->start[i]; /* reset this position*/
#243      localstatus = NC_get_vara(ncid,varid,odom.index,nc_sizevector1,memptr,memtype);
dvarput.c#14    size_t         index[NC_MAX_VAR_DIMS];
#35 odom->index[i] = odom->start[i];
#42    return (odom->index[0] < odom->stop[0]);
#51        odom->index[i] += (size_t)odom->stride[i];
#52        if(odom->index[i] < odom->stop[i]) break;
#54 odom->index[i] = odom->start[i]; /* reset this position*/
#252      localstatus = NC_put_vara(ncid,varid,odom.index,nc_sizevector1,memptr,memtype);
generate.c#48 ASSERT(odom->index[i] == odom->start[i]+odom->count[i]);
genf77.c#558    int index;
#562    for(index=1;(c=*p);) {
#564 bbprintf0(stmt,"%s(%d) = ",where,index);
#568 index++;
#749 int index = listlength(f77procs);
#756          f77name(vsym),index,f77name(vsym));
#768                        f77name(vsym),index,f77name(vsym));
getfill.c#15static void fillarray(SymboltsymDimsetdimset, int indexDatalist*);
#118fillarray(SymbolbasetypeDimsetdimset, int indexDatalistarraylist)
#121    Symboldim = dimset->dimsyms[index];
#124    int lastdim = (index == (dimset->ndims - 1));
#125    int firstdim = (index == 0);
#134     fillarray(basetype->typ.basetype,dimset,index+1,sublist);
#141         fillarray(basetype->typ.basetype,dimset,index+1,sublist);
getvara.c#545                                            odom->index,&dimcontent);
#835         ocstat = oc_data_readn(conn,currentcontent,odom->index,count,internlen,memory->next);
#851         ocstat = oc_data_readn(conn,currentcontent,odom->index,1,interntypesize,value);
#869         ocstat = oc_data_readn(conn,currentcontent,odom->index,1,interntypesize,value);
#969     ocstat = oc_data_readn(conn,currentcontent,odom->index,1,sizeof(value),&value);
#1359 size_t* indexset = odom->index;
list.c#77listget(Listl, unsigned long index)
#80  if(index >= l->length) return NULL;
#81  return l->content[index];
#85listset(Listl, unsigned long index, void* elem)
#88  if(index >= l->length) return FALSE;
#89  l->content[index] = elem;
#95listinsert(Listl, unsigned long index, void* elem)
#99  if(index > l->length) return FALSE;
#101  for(i=(int)l->length;i>index;i--) l->content[i] = l->content[i-1];
#102  l->content[index] = elem;
nc3internal.c#154 off_t index = 0;
#181   index = (off_tncp->xsz;
#182   ncp->begin_var = D_RNDUP(indexv_align);
#183   if(ncp->begin_var < index + h_minfree)
#185     ncp->begin_var = D_RNDUP(index + (off_t)h_minfreev_align);
#195 index = ncp->begin_var;
#210fprintf(stderr, "    VAR %d %s: %ld\n", ii, (*vpp)->name->cp, (long)index);
#212                if( sizeof_off_t == 4 && (index > X_OFF_MAX || index < 0) )
#216 (*vpp)->begin = index;
#231              index = (*vpp)->begin;
#237 index += (*vpp)->len;
#249 if (ncp->begin_rec < index + v_minfree ||
#252   ncp->begin_rec = D_RNDUP(indexr_align);
#253   if(ncp->begin_rec < index + v_minfree)
#255     ncp->begin_rec = D_RNDUP(index + (off_t)v_minfreer_align);
#264 index = ncp->begin_rec;
#280fprintf(stderr, "    REC %d %s: %ld\n", ii, (*vpp)->name->cp, (long)index);
#282                if( sizeof_off_t == 4 && (index > X_OFF_MAX || index < 0) )
#286 (*vpp)->begin = index;
#301 index += (*vpp)->len;
nc_hashmap.c#140    unsigned long index = key % hash->size;
#145      if (hash->table[index].flags & ACTIVE)
#147 hEntry entry = hash->table[index];
#152   hash->table[index].data = data+1;
#158 hash->table[index].flags |= ACTIVE;
#159 hash->table[index].data = data+1;
#160 hash->table[index].key = key;
#165      index = (index + step) % hash->size;
#187    unsigned long index = key % hash->size;
#192      if (hash->table[index].flags & ACTIVE)
#194 hEntry entry = hash->table[index];
#199   hash->table[index].data = data+1;
#205 hash->table[index].flags |= ACTIVE;
#206 hash->table[index].data = data+1;
#207 hash->table[index].key = key;
#212      index = (index + step) % hash->size;
#228  unsigned long index = key % hash->size;
#233    if (hash->table[index].data > 0)
#235      hEntry entry = hash->table[index];
#240 if (hash->table[index].flags & ACTIVE)
#242   hash->table[index].flags &= ~ACTIVE;
#244   return hash->table[index].data-1;
#253    index = (index + step) % hash->size;
#265  unsigned long index = key % hash->size;
#270    if (hash->table[index].data > 0)
#272      hEntry entry = hash->table[index];
#277 if (hash->table[index].flags & ACTIVE)
#279   hash->table[index].flags &= ~ACTIVE;
#281   return hash->table[index].data-1;
#290    index = (index + step) % hash->size;
#305    unsigned long index = key % hash->size;
#310      hEntry entry = hash->table[index];
#323      index = (index + step) % hash->size;
#339    unsigned long index = key % hash->size;
#344      hEntry entry = hash->table[index];
#357      index = (index + step) % hash->size;
ncaux.c#302    int index = 0;
#304      case NC_BYTEindex = UCHARINDEX; break;
#305      case NC_CHARindex = CHARINDEX; break;
#306      case NC_SHORTindex = SHORTINDEX; break;
#307      case NC_INTindex = INTINDEX; break;
#308      case NC_FLOATindex = FLOATINDEX; break;
#309      case NC_DOUBLEindex = DOUBLEINDEX; break;
#310      case NC_UBYTEindex = UCHARINDEX; break;
#311      case NC_USHORTindex = USHORTINDEX; break;
#312      case NC_UINTindex = UINTINDEX; break;
#313      case NC_INT64index = LONGLONGINDEX; break;
#314      case NC_UINT64index = ULONGLONGINDEX; break;
#315      case NC_STRINGindex = PTRINDEX; break;
#316      case NC_VLENindex = NCVLENINDEX; break;
#317      case NC_OPAQUEindex = UCHARINDEX; break;
#320    align = &vec[index];
ncbytes.c#92ncbytesget(NCbytesbb, unsigned long index)
#95  if(index >= bb->length) return -1;
#96  return bb->content[index];
#100ncbytesset(NCbytesbb, unsigned long index, char elem)
#103  if(index >= bb->length) return ncbytesfail();
#104  bb->content[index] = elem;
ncd2dispatch.c#1684    int index;
#1725     index = fieldindex(current,next);
#1727     ocstat = oc_data_ithfield(conn,data,index,&nextdata);
nchashmap.c#165nchashith(NChashmaphm, int indexnchashidhashp, void** elemp)
#173 if((index - len) < 0) {
#174     if(hashp) *hashp = (nchashid)nclistget(seq,index*2);
#175     if(elemp) *elemp = nclistget(seq,(index*2)+1);
#178 index -= len;
#188    int i,j,index;
#195        for(index=0,i=0;i<hm->alloc;i++) {
#198         keys[index++] = (nchashid)nclistget(seq,j);
nclist.c#77nclistget(NClistl, unsigned long index)
#80  if(index >= l->length) return NULL;
#81  return l->content[index];
#85nclistset(NClistl, unsigned long index, void* elem)
#88  if(index >= l->length) return FALSE;
#89  l->content[index] = elem;
#95nclistinsert(NClistl, unsigned long index, void* elem)
#99  if(index > l->length) return FALSE;
#101  for(i=(int)l->length;i>index;i--) l->content[i] = l->content[i-1];
#102  l->content[index] = elem;
nclistmgr.c#116iterate_NCList(int indexNC** ncp)
#119    if(index < 0 || index >= NCFILELISTLENGTH)
#121    if(ncp) *ncp = nc_filelist[index];
oc.c#447oc_dds_ithfield(OCobject linkOCobject ddsnode, size_t indexOCobjectfieldnodep)
#457    if(index >= oclistlength(node->subnodes))
#460    field = (OCnode*)oclistget(node->subnodes,index);
#480oc_dds_ithsubnode(OCobject linkOCobject ddsnode, size_t indexOCobjectfieldnodep)
#482    return OCTHROW(oc_dds_ithfield(link,ddsnode,index,fieldnodep));
#519oc_dds_gridmap(OCobject linkOCobject grid, size_t indexOCobjectmapnodep)
#521    return OCTHROW(oc_dds_ithfield(link,grid,index+1,mapnodep));
#622oc_dds_ithdimension(OCobject linkOCobject ddsnode, size_t indexOCobjectdimidp)
#630    if(index >= node->array.rank) return OCTHROW(OCTHROW(OC_EINDEX));
#631    dimid = (OCobject)oclistget(node->array.dimensions,index);
#725oc_dds_attr(OCobject linkOCobject ddsnode, size_t index,
#737    if(index >= nattrs) return OCTHROW(OCTHROW(OC_EINDEX));
#738    attr = (OCattribute*)oclistget(node->attributes,index);
#813oc_das_attr(OCobject linkOCobject dasnode, size_t indexOCtypeatomtypep, char** valuep)
#822    if(index >= nvalues) return OCTHROW(OCTHROW(OC_EINDEX));
#824    if(valuep) *valuep = nulldup((char*)oclistget(attr->att.values,index));
#922oc_data_ithfield(OCobject linkOCobject datanode, size_t indexOCobjectfieldp)
#934    ocerr = ocdata_ithfield(state,data,index,&field);
#1030oc_data_gridmap(OCobject linkOCobject grid, size_t indexOCobjectmapdatap)
#1032    return OCTHROW(oc_data_ithfield(link,grid,index+1,mapdatap));
#1153extern OCerror oc_data_ithrecord(OCobject linkOCobject datanode, size_t indexOCobjectrecordp)
#1165    ocerr = ocdata_ithrecord(state,data,index,&record);
oc.h#255extern OCerror oc_dds_ithfield(OClinkOCddsnode, size_t indexOCddsnodeithfieldp);
#268extern OCerror oc_dds_gridmap(OClinkOCddsnode grid, size_t indexOCddsnodemapp);
#376extern OCerror oc_data_ithfield(OClinkOCdatanode container, size_t index,
#388extern OCerror oc_data_gridmap(OClinkOCdatanode grid, size_t indexOCdatanodemapp);
#396extern OCerror oc_data_ithrecord(OClinkOCdatanode data, size_t indexOCdatanoderecordp);
ocbytes.c#92ocbytesget(OCbytesbb, size_t index)
#95  if(index >= bb->length) return -1;
#96  return bb->content[index];
#100ocbytesset(OCbytesbb, size_t index, char elem)
#103  if(index >= bb->length) return ocbytesfail();
#104  bb->content[index] = elem;
occompile.c#127 instance->index = i;
#156 record->index = nelements;
#263        fieldinstance->index = i;
ocdata.c#88ocdata_ithfield(OCstatestateOCdatacontainer, size_t indexOCdata** fieldp)
#102    if(index >= container->ninstances)
#105    field = container->instances[index];
#119    size_t index,rank;
#136    index = ocarrayoffset(rank,pattern->array.sizes,indices);
#138    if(index >= data->ninstances)
#141    element = data->instances[index];
#153                 size_t index, /* record number */
#172    if(index >= data->ninstances)
#175    record = data->instances[index];
#195 indices[0] = data->index;
#198 ocarrayindices(data->index,
ocdata.h#19    size_t    index;     /* WRT to the container */
#33extern OCerror ocdata_ithfield(OCstate*, OCdatacontainer, size_t indexOCdata** fieldp);
#38extern OCerror ocdata_ithrecord(OCstate*, OCdatadata, size_t indexOCdata** recordp);
ocdump.c#29static void dumpattvalue(OCtype nctype, char** aset, int index);
#201dumpattvalue(OCtype nctype, char** strings, int index)
#204        fprintf(stdout,"\"%s\"",strings[index]);
#206        fprintf(stdout,"%s",strings[index]);
#255dumpfield(size_t index, char* n8, int isxdr)
#275    sprintf(tmp,"%6zd",index);
#583        snprintf(tmp,sizeof(tmp),"%04lu ",(unsigned long)data->index);
#659 snprintf(tmp,sizeof(tmp),".%lu",(unsigned long)next->index);
oclist.c#77oclistget(OClistl, size_t index)
#80  if(index >= l->length) return NULL;
#81  return l->content[index];
#85oclistset(OClistl, size_t index, void* elem)
#88  if(index >= l->length) return FALSE;
#89  l->content[index] = elem;
#95oclistinsert(OClistl, size_t index, void* elem)
#99  if(index > l->length) return FALSE;
#101  for(i=(int)l->length;i>index;i--) l->content[i] = l->content[i-1];
#102  l->content[index] = elem;
ocutil.c#486ocarrayindices(size_t index, size_t rank, size_t* sizes, size_t* indices)
#490 indices[i] = index % sizes[i];
#491 index = (index - indices[i]) / sizes[i];
ocutil.h#31extern void ocarrayindices(size_t index, size_t rank, size_t*, size_t*);
odom.c#33 odom->index[i] = odom->start[i];
#74 (unsigned long)odom->origin->index[ioffset],
#87    size_t index,start,count;
#90    index = odom->origin->index[offset];
#93    if(index < start + count) return 1;
#95    odom->origin->index[offset] = odom->origin->start[offset];
#107        odom->origin->index[ioffset]++;
#108 if(odom->origin->index[ioffset]
#113 odom->origin->index[ioffset] = odom->origin->start[ioffset];
#138 count += odom->origin->index[ioffset];
odom.h#15    size_t    index[NC_MAX_VAR_DIMS];
offsets.c#112    int index = 0;
#114      case NC_BYTEindex = UCHARINDEX; break;
#115      case NC_CHARindex = CHARINDEX; break;
#116      case NC_SHORTindex = SHORTINDEX; break;
#117      case NC_INTindex = INTINDEX; break;
#118      case NC_FLOATindex = FLOATINDEX; break;
#119      case NC_DOUBLEindex = DOUBLEINDEX; break;
#120      case NC_UBYTEindex = UCHARINDEX; break;
#121      case NC_USHORTindex = USHORTINDEX; break;
#122      case NC_UINTindex = UINTINDEX; break;
#123      case NC_INT64index = LONGLONGINDEX; break;
#124      case NC_UINT64index = ULONGLONGINDEX; break;
#125      case NC_STRINGindex = PTRINDEX; break;
#126      case NC_VLENindex = NCVLENINDEX; break;
#127      case NC_OPAQUEindex = UCHARINDEX; break;
#132    align = &vec[index];
putget.c#10403    const size_t index = ii;
#10428        odo1(startuppercoord, &upper[index], &coord[index]);
#10536    const size_t index = ii;
#10561        odo1(startuppercoord, &upper[index], &coord[index]);
quick_large_files.c#41    size_t index[2] = {QTR_CLASSIC_MAX-1, 0};
#91 if ((res = nc_put_var1_double(ncidkirkidindex, &double_val_out)))
#160 index[0] = QTR_CLASSIC_MAX - 295;
#161 if ((res = nc_put_var1_int(ncidnapoleanidindex, &int_val_out)))
#163 if ((res = nc_get_var1_int(ncidnapoleanidindex, &int_val_in)))
#168 index[0] = QTR_CLASSIC_MAX - 1;
#169 if ((res = nc_put_var1_int(ncidnapoleanidindex, &int_val_out)))
#171 if ((res = nc_get_var1_int(ncidnapoleanidindex, &int_val_in)))
#176 index[0] = QTR_CLASSIC_MAX - 1;
#177 if ((res = nc_put_var1_int(ncidwashingtonidindex, &int_val_out)))
#179 if ((res = nc_get_var1_int(ncidwashingtonidindex, &int_val_in)))
#394 index[0] = 0;
#395 index[1] = MAX_CLASSIC_BYTES - 1;
#396 if ((res = nc_put_var1_double(ncidcromwellidindex, &double_val_out)))
#398 if ((res = nc_get_var1_double(ncidcromwellidindex, &double_val_in)))
#437 index[0] = 0;
#438 index[1] = MAX_CLASSIC_BYTES - 1;
#439 if ((res = nc_put_var1_double(ncidcromwellidindex, &double_val_out)))
#441 if ((res = nc_get_var1_double(ncidcromwellidindex, &double_val_in)))
#553 index[0] = 0;
#554 index[1] = MAX_CLASSIC_BYTES - 1;
#555 if ((res = nc_put_var1_int(ncidcromwellidindex, &int_val_out)))
#557 if ((res = nc_get_var1_int(ncidcromwellidindex, &int_val_in)))
test_get.c#24    size_t index[MAX_RANK];
#35     index[j] = 0;
#36        err = nc_get_var1_text(BAD_IDiindex, &value);
#39        err = nc_get_var1_text(ncidBAD_VARIDindex, &value);
#43     index[j] = var_shape[i][j];
#44     err = nc_get_var1_text(ncidiindex, &value);
#50     index[j] = 0;
#53     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#56     expect = hash4var_type[i], var_rank[i], indexNCT_TEXT );
#60 err = nc_get_var1_text(ncidiindex, &value);
#102    size_t index[MAX_RANK];
#113     index[j] = 0;
#114        err = nc_get_var1_uchar(BAD_IDiindex, &value);
#117        err = nc_get_var1_uchar(ncidBAD_VARIDindex, &value);
#121     index[j] = var_shape[i][j];
#122     err = nc_get_var1_uchar(ncidiindex, &value);
#128     index[j] = 0;
#131     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#134     expect = hash4var_type[i], var_rank[i], indexNCT_UCHAR );
#138 err = nc_get_var1_uchar(ncidiindex, &value);
#180    size_t index[MAX_RANK];
#191     index[j] = 0;
#192        err = nc_get_var1_schar(BAD_IDiindex, &value);
#195        err = nc_get_var1_schar(ncidBAD_VARIDindex, &value);
#199     index[j] = var_shape[i][j];
#200     err = nc_get_var1_schar(ncidiindex, &value);
#206     index[j] = 0;
#209     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#212     expect = hash4var_type[i], var_rank[i], indexNCT_SCHAR );
#216 err = nc_get_var1_schar(ncidiindex, &value);
#258    size_t index[MAX_RANK];
#269     index[j] = 0;
#270        err = nc_get_var1_short(BAD_IDiindex, &value);
#273        err = nc_get_var1_short(ncidBAD_VARIDindex, &value);
#277     index[j] = var_shape[i][j];
#278     err = nc_get_var1_short(ncidiindex, &value);
#284     index[j] = 0;
#287     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#290     expect = hash4var_type[i], var_rank[i], indexNCT_SHORT );
#294 err = nc_get_var1_short(ncidiindex, &value);
#336    size_t index[MAX_RANK];
#347     index[j] = 0;
#348        err = nc_get_var1_int(BAD_IDiindex, &value);
#351        err = nc_get_var1_int(ncidBAD_VARIDindex, &value);
#355     index[j] = var_shape[i][j];
#356     err = nc_get_var1_int(ncidiindex, &value);
#362     index[j] = 0;
#365     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#368     expect = hash4var_type[i], var_rank[i], indexNCT_INT );
#372 err = nc_get_var1_int(ncidiindex, &value);
#414    size_t index[MAX_RANK];
#425     index[j] = 0;
#426        err = nc_get_var1_long(BAD_IDiindex, &value);
#429        err = nc_get_var1_long(ncidBAD_VARIDindex, &value);
#433     index[j] = var_shape[i][j];
#434     err = nc_get_var1_long(ncidiindex, &value);
#440     index[j] = 0;
#443     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#446     expect = hash4var_type[i], var_rank[i], indexNCT_LONG );
#450 err = nc_get_var1_long(ncidiindex, &value);
#492    size_t index[MAX_RANK];
#503     index[j] = 0;
#504        err = nc_get_var1_float(BAD_IDiindex, &value);
#507        err = nc_get_var1_float(ncidBAD_VARIDindex, &value);
#511     index[j] = var_shape[i][j];
#512     err = nc_get_var1_float(ncidiindex, &value);
#518     index[j] = 0;
#521     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#524     expect = hash4var_type[i], var_rank[i], indexNCT_FLOAT );
#528 err = nc_get_var1_float(ncidiindex, &value);
#570    size_t index[MAX_RANK];
#581     index[j] = 0;
#582        err = nc_get_var1_double(BAD_IDiindex, &value);
#585        err = nc_get_var1_double(ncidBAD_VARIDindex, &value);
#589     index[j] = var_shape[i][j];
#590     err = nc_get_var1_double(ncidiindex, &value);
#596     index[j] = 0;
#599     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#602     expect = hash4var_type[i], var_rank[i], indexNCT_DOUBLE );
#606 err = nc_get_var1_double(ncidiindex, &value);
#648    size_t index[MAX_RANK];
#659     index[j] = 0;
#660        err = nc_get_var1_ushort(BAD_IDiindex, &value);
#663        err = nc_get_var1_ushort(ncidBAD_VARIDindex, &value);
#667     index[j] = var_shape[i][j];
#668     err = nc_get_var1_ushort(ncidiindex, &value);
#674     index[j] = 0;
#677     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#680     expect = hash4var_type[i], var_rank[i], indexNCT_USHORT );
#684 err = nc_get_var1_ushort(ncidiindex, &value);
#726    size_t index[MAX_RANK];
#737     index[j] = 0;
#738        err = nc_get_var1_uint(BAD_IDiindex, &value);
#741        err = nc_get_var1_uint(ncidBAD_VARIDindex, &value);
#745     index[j] = var_shape[i][j];
#746     err = nc_get_var1_uint(ncidiindex, &value);
#752     index[j] = 0;
#755     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#758     expect = hash4var_type[i], var_rank[i], indexNCT_UINT );
#762 err = nc_get_var1_uint(ncidiindex, &value);
#804    size_t index[MAX_RANK];
#815     index[j] = 0;
#816        err = nc_get_var1_longlong(BAD_IDiindex, &value);
#819        err = nc_get_var1_longlong(ncidBAD_VARIDindex, &value);
#823     index[j] = var_shape[i][j];
#824     err = nc_get_var1_longlong(ncidiindex, &value);
#830     index[j] = 0;
#833     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#836     expect = hash4var_type[i], var_rank[i], indexNCT_LONGLONG );
#840 err = nc_get_var1_longlong(ncidiindex, &value);
#882    size_t index[MAX_RANK];
#893     index[j] = 0;
#894        err = nc_get_var1_ulonglong(BAD_IDiindex, &value);
#897        err = nc_get_var1_ulonglong(ncidBAD_VARIDindex, &value);
#901     index[j] = var_shape[i][j];
#902     err = nc_get_var1_ulonglong(ncidiindex, &value);
#908     index[j] = 0;
#911     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#914     expect = hash4var_type[i], var_rank[i], indexNCT_ULONGLONG );
#918 err = nc_get_var1_ulonglong(ncidiindex, &value);
#966    size_t index[MAX_RANK];
#991     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#994     expect[j] = hash4(var_type[i], var_rank[i], indexNCT_TEXT);
#1056    size_t index[MAX_RANK];
#1081     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1084     expect[j] = hash4(var_type[i], var_rank[i], indexNCT_UCHAR);
#1146    size_t index[MAX_RANK];
#1171     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1174     expect[j] = hash4(var_type[i], var_rank[i], indexNCT_SCHAR);
#1236    size_t index[MAX_RANK];
#1261     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1264     expect[j] = hash4(var_type[i], var_rank[i], indexNCT_SHORT);
#1326    size_t index[MAX_RANK];
#1351     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1354     expect[j] = hash4(var_type[i], var_rank[i], indexNCT_INT);
#1416    size_t index[MAX_RANK];
#1441     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1444     expect[j] = hash4(var_type[i], var_rank[i], indexNCT_LONG);
#1506    size_t index[MAX_RANK];
#1531     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1534     expect[j] = hash4(var_type[i], var_rank[i], indexNCT_FLOAT);
#1596    size_t index[MAX_RANK];
#1621     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1624     expect[j] = hash4(var_type[i], var_rank[i], indexNCT_DOUBLE);
#1686    size_t index[MAX_RANK];
#1711     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1714     expect[j] = hash4(var_type[i], var_rank[i], indexNCT_USHORT);
#1776    size_t index[MAX_RANK];
#1801     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1804     expect[j] = hash4(var_type[i], var_rank[i], indexNCT_UINT);
#1866    size_t index[MAX_RANK];
#1891     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1894     expect[j] = hash4(var_type[i], var_rank[i], indexNCT_LONGLONG);
#1956    size_t index[MAX_RANK];
#1981     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1984     expect[j] = hash4(var_type[i], var_rank[i], indexNCT_ULONGLONG);
#2054    size_t index[MAX_RANK];
#2134                err = toMixedBase(jvar_rank[i], edgeindex);
#2138                    index[d] += start[d];
#2139                expect[j] = hash4(var_type[i], var_rank[i], indexNCT_TEXT);
#2210    size_t index[MAX_RANK];
#2290                err = toMixedBase(jvar_rank[i], edgeindex);
#2294                    index[d] += start[d];
#2295                expect[j] = hash4(var_type[i], var_rank[i], indexNCT_UCHAR);
#2366    size_t index[MAX_RANK];
#2446                err = toMixedBase(jvar_rank[i], edgeindex);
#2450                    index[d] += start[d];
#2451                expect[j] = hash4(var_type[i], var_rank[i], indexNCT_SCHAR);
#2522    size_t index[MAX_RANK];
#2602                err = toMixedBase(jvar_rank[i], edgeindex);
#2606                    index[d] += start[d];
#2607                expect[j] = hash4(var_type[i], var_rank[i], indexNCT_SHORT);
#2678    size_t index[MAX_RANK];
#2758                err = toMixedBase(jvar_rank[i], edgeindex);
#2762                    index[d] += start[d];
#2763                expect[j] = hash4(var_type[i], var_rank[i], indexNCT_INT);
#2834    size_t index[MAX_RANK];
#2914                err = toMixedBase(jvar_rank[i], edgeindex);
#2918                    index[d] += start[d];
#2919                expect[j] = hash4(var_type[i], var_rank[i], indexNCT_LONG);
#2990    size_t index[MAX_RANK];
#3070                err = toMixedBase(jvar_rank[i], edgeindex);
#3074                    index[d] += start[d];
#3075                expect[j] = hash4(var_type[i], var_rank[i], indexNCT_FLOAT);
#3146    size_t index[MAX_RANK];
#3226                err = toMixedBase(jvar_rank[i], edgeindex);
#3230                    index[d] += start[d];
#3231                expect[j] = hash4(var_type[i], var_rank[i], indexNCT_DOUBLE);
#3302    size_t index[MAX_RANK];
#3382                err = toMixedBase(jvar_rank[i], edgeindex);
#3386                    index[d] += start[d];
#3387                expect[j] = hash4(var_type[i], var_rank[i], indexNCT_USHORT);
#3458    size_t index[MAX_RANK];
#3538                err = toMixedBase(jvar_rank[i], edgeindex);
#3542                    index[d] += start[d];
#3543                expect[j] = hash4(var_type[i], var_rank[i], indexNCT_UINT);
#3614    size_t index[MAX_RANK];
#3694                err = toMixedBase(jvar_rank[i], edgeindex);
#3698                    index[d] += start[d];
#3699                expect[j] = hash4(var_type[i], var_rank[i], indexNCT_LONGLONG);
#3770    size_t index[MAX_RANK];
#3850                err = toMixedBase(jvar_rank[i], edgeindex);
#3854                    index[d] += start[d];
#3855                expect[j] = hash4(var_type[i], var_rank[i], indexNCT_ULONGLONG);
#3931    size_t index[MAX_RANK];
#4004                err = toMixedBase(mvar_rank[i], sstrideindex);
#4009                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#4011                    index[j] += start[j];
#4028 index2[d] = index[d] + index2[d] * stride[d];
#4041                    err = nc_get_vars_text(ncidiindexcountstridevalue);
#4105    size_t index[MAX_RANK];
#4178                err = toMixedBase(mvar_rank[i], sstrideindex);
#4183                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#4185                    index[j] += start[j];
#4202 index2[d] = index[d] + index2[d] * stride[d];
#4215                    err = nc_get_vars_uchar(ncidiindexcountstridevalue);
#4279    size_t index[MAX_RANK];
#4352                err = toMixedBase(mvar_rank[i], sstrideindex);
#4357                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#4359                    index[j] += start[j];
#4376 index2[d] = index[d] + index2[d] * stride[d];
#4389                    err = nc_get_vars_schar(ncidiindexcountstridevalue);
#4453    size_t index[MAX_RANK];
#4526                err = toMixedBase(mvar_rank[i], sstrideindex);
#4531                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#4533                    index[j] += start[j];
#4550 index2[d] = index[d] + index2[d] * stride[d];
#4563                    err = nc_get_vars_short(ncidiindexcountstridevalue);
#4627    size_t index[MAX_RANK];
#4700                err = toMixedBase(mvar_rank[i], sstrideindex);
#4705                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#4707                    index[j] += start[j];
#4724 index2[d] = index[d] + index2[d] * stride[d];
#4737                    err = nc_get_vars_int(ncidiindexcountstridevalue);
#4801    size_t index[MAX_RANK];
#4874                err = toMixedBase(mvar_rank[i], sstrideindex);
#4879                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#4881                    index[j] += start[j];
#4898 index2[d] = index[d] + index2[d] * stride[d];
#4911                    err = nc_get_vars_long(ncidiindexcountstridevalue);
#4975    size_t index[MAX_RANK];
#5048                err = toMixedBase(mvar_rank[i], sstrideindex);
#5053                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#5055                    index[j] += start[j];
#5072 index2[d] = index[d] + index2[d] * stride[d];
#5085                    err = nc_get_vars_float(ncidiindexcountstridevalue);
#5149    size_t index[MAX_RANK];
#5222                err = toMixedBase(mvar_rank[i], sstrideindex);
#5227                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#5229                    index[j] += start[j];
#5246 index2[d] = index[d] + index2[d] * stride[d];
#5259                    err = nc_get_vars_double(ncidiindexcountstridevalue);
#5323    size_t index[MAX_RANK];
#5396                err = toMixedBase(mvar_rank[i], sstrideindex);
#5401                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#5403                    index[j] += start[j];
#5420 index2[d] = index[d] + index2[d] * stride[d];
#5433                    err = nc_get_vars_ushort(ncidiindexcountstridevalue);
#5497    size_t index[MAX_RANK];
#5570                err = toMixedBase(mvar_rank[i], sstrideindex);
#5575                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#5577                    index[j] += start[j];
#5594 index2[d] = index[d] + index2[d] * stride[d];
#5607                    err = nc_get_vars_uint(ncidiindexcountstridevalue);
#5671    size_t index[MAX_RANK];
#5744                err = toMixedBase(mvar_rank[i], sstrideindex);
#5749                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#5751                    index[j] += start[j];
#5768 index2[d] = index[d] + index2[d] * stride[d];
#5781                    err = nc_get_vars_longlong(ncidiindexcountstridevalue);
#5845    size_t index[MAX_RANK];
#5918                err = toMixedBase(mvar_rank[i], sstrideindex);
#5923                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#5925                    index[j] += start[j];
#5942 index2[d] = index[d] + index2[d] * stride[d];
#5955                    err = nc_get_vars_ulonglong(ncidiindexcountstridevalue);
#6022    size_t index[MAX_RANK];
#6097                err = toMixedBase(mvar_rank[i], sstrideindex);
#6102                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#6104                    index[j] += start[j];
#6127                        index2[d] = index[d] + index2[d] * stride[d];
#6140                    err = nc_get_varm_text(ncid,i,index,count,stride,imap,value);
#6204    size_t index[MAX_RANK];
#6279                err = toMixedBase(mvar_rank[i], sstrideindex);
#6284                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#6286                    index[j] += start[j];
#6309                        index2[d] = index[d] + index2[d] * stride[d];
#6322                    err = nc_get_varm_uchar(ncid,i,index,count,stride,imap,value);
#6386    size_t index[MAX_RANK];
#6461                err = toMixedBase(mvar_rank[i], sstrideindex);
#6466                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#6468                    index[j] += start[j];
#6491                        index2[d] = index[d] + index2[d] * stride[d];
#6504                    err = nc_get_varm_schar(ncid,i,index,count,stride,imap,value);
#6568    size_t index[MAX_RANK];
#6643                err = toMixedBase(mvar_rank[i], sstrideindex);
#6648                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#6650                    index[j] += start[j];
#6673                        index2[d] = index[d] + index2[d] * stride[d];
#6686                    err = nc_get_varm_short(ncid,i,index,count,stride,imap,value);
#6750    size_t index[MAX_RANK];
#6825                err = toMixedBase(mvar_rank[i], sstrideindex);
#6830                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#6832                    index[j] += start[j];
#6855                        index2[d] = index[d] + index2[d] * stride[d];
#6868                    err = nc_get_varm_int(ncid,i,index,count,stride,imap,value);
#6932    size_t index[MAX_RANK];
#7007                err = toMixedBase(mvar_rank[i], sstrideindex);
#7012                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7014                    index[j] += start[j];
#7037                        index2[d] = index[d] + index2[d] * stride[d];
#7050                    err = nc_get_varm_long(ncid,i,index,count,stride,imap,value);
#7114    size_t index[MAX_RANK];
#7189                err = toMixedBase(mvar_rank[i], sstrideindex);
#7194                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7196                    index[j] += start[j];
#7219                        index2[d] = index[d] + index2[d] * stride[d];
#7232                    err = nc_get_varm_float(ncid,i,index,count,stride,imap,value);
#7296    size_t index[MAX_RANK];
#7371                err = toMixedBase(mvar_rank[i], sstrideindex);
#7376                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7378                    index[j] += start[j];
#7401                        index2[d] = index[d] + index2[d] * stride[d];
#7414                    err = nc_get_varm_double(ncid,i,index,count,stride,imap,value);
#7478    size_t index[MAX_RANK];
#7553                err = toMixedBase(mvar_rank[i], sstrideindex);
#7558                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7560                    index[j] += start[j];
#7583                        index2[d] = index[d] + index2[d] * stride[d];
#7596                    err = nc_get_varm_ushort(ncid,i,index,count,stride,imap,value);
#7660    size_t index[MAX_RANK];
#7735                err = toMixedBase(mvar_rank[i], sstrideindex);
#7740                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7742                    index[j] += start[j];
#7765                        index2[d] = index[d] + index2[d] * stride[d];
#7778                    err = nc_get_varm_uint(ncid,i,index,count,stride,imap,value);
#7842    size_t index[MAX_RANK];
#7917                err = toMixedBase(mvar_rank[i], sstrideindex);
#7922                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7924                    index[j] += start[j];
#7947                        index2[d] = index[d] + index2[d] * stride[d];
#7960                    err = nc_get_varm_longlong(ncid,i,index,count,stride,imap,value);
#8024    size_t index[MAX_RANK];
#8099                err = toMixedBase(mvar_rank[i], sstrideindex);
#8104                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#8106                    index[j] += start[j];
#8129                        index2[d] = index[d] + index2[d] * stride[d];
#8142                    err = nc_get_varm_ulonglong(ncid,i,index,count,stride,imap,value);
test_partvar.c#42    size_t* index;
#197    odom->index = (size_t*)calloc(sizeof(size_t)*rank,1);
#207    free(odom->index);
#224        odom->index[i] = odom->start[i];
#232    return (odom->index[0] < odom->stop[0]?1:0);
#241        odom->index[i]++;
#242        if(odom->index[i] < odom->stop[i]) break;
#244 odom->index[i] = odom->start[i]; /* reset this position*/
#257 offset += odom->index[i];
test_put.c#24    const size_t *index,
#30    return MAX(minMIN(maxhash4typerankindexitype)));
#41    const size_t *index,
#47    return MAX(minMIN(maxhash4typerankindexitype)));
#58    const size_t *index,
#64    return MAX(minMIN(maxhash4typerankindexitype)));
#75    const size_t *index,
#81    return MAX(minMIN(maxhash4typerankindexitype)));
#92    const size_t *index,
#98    return MAX(minMIN(maxhash4typerankindexitype)));
#109    const size_t *index,
#115    return MAX(minMIN(maxhash4typerankindexitype)));
#126    const size_t *index,
#132    return MAX(minMIN(maxhash4typerankindexitype)));
#143    const size_t *index,
#149    return MAX(minMIN(maxhash4typerankindexitype)));
#160    const size_t *index,
#166    return MAX(minMIN(maxhash4typerankindexitype)));
#177    const size_t *index,
#183    return MAX(minMIN(maxhash4typerankindexitype)));
#194    const size_t *index,
#200    return MAX(minMIN(maxhash4typerankindexitype)));
#211    const size_t *index,
#217    return MAX(minMIN(maxhash4typerankindexitype)));
#231    size_t index[MAX_RANK];
#270 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#273 expect = hash4var_type[i], var_rank[i], indexNCT_TEXT);
#274 err = nc_get_var1_text(ncidiindex, &value);
#288 error(" %d", index[d]);
#315    size_t index[MAX_RANK];
#354 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#357 expect = hash4var_type[i], var_rank[i], indexNCT_UCHAR);
#358 err = nc_get_var1_uchar(ncidiindex, &value);
#372 error(" %d", index[d]);
#399    size_t index[MAX_RANK];
#438 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#441 expect = hash4var_type[i], var_rank[i], indexNCT_SCHAR);
#442 err = nc_get_var1_schar(ncidiindex, &value);
#456 error(" %d", index[d]);
#483    size_t index[MAX_RANK];
#522 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#525 expect = hash4var_type[i], var_rank[i], indexNCT_SHORT);
#526 err = nc_get_var1_short(ncidiindex, &value);
#540 error(" %d", index[d]);
#567    size_t index[MAX_RANK];
#606 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#609 expect = hash4var_type[i], var_rank[i], indexNCT_INT);
#610 err = nc_get_var1_int(ncidiindex, &value);
#624 error(" %d", index[d]);
#651    size_t index[MAX_RANK];
#690 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#693 expect = hash4var_type[i], var_rank[i], indexNCT_LONG);
#694 err = nc_get_var1_long(ncidiindex, &value);
#708 error(" %d", index[d]);
#735    size_t index[MAX_RANK];
#774 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#777 expect = hash4var_type[i], var_rank[i], indexNCT_FLOAT);
#778 err = nc_get_var1_float(ncidiindex, &value);
#792 error(" %d", index[d]);
#819    size_t index[MAX_RANK];
#858 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#861 expect = hash4var_type[i], var_rank[i], indexNCT_DOUBLE);
#862 err = nc_get_var1_double(ncidiindex, &value);
#876 error(" %d", index[d]);
#903    size_t index[MAX_RANK];
#942 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#945 expect = hash4var_type[i], var_rank[i], indexNCT_USHORT);
#946 err = nc_get_var1_ushort(ncidiindex, &value);
#960 error(" %d", index[d]);
#987    size_t index[MAX_RANK];
#1026 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1029 expect = hash4var_type[i], var_rank[i], indexNCT_UINT);
#1030 err = nc_get_var1_uint(ncidiindex, &value);
#1044 error(" %d", index[d]);
#1071    size_t index[MAX_RANK];
#1110 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1113 expect = hash4var_type[i], var_rank[i], indexNCT_LONGLONG);
#1114 err = nc_get_var1_longlong(ncidiindex, &value);
#1128 error(" %d", index[d]);
#1155    size_t index[MAX_RANK];
#1194 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1197 expect = hash4var_type[i], var_rank[i], indexNCT_ULONGLONG);
#1198 err = nc_get_var1_ulonglong(ncidiindex, &value);
#1212 error(" %d", index[d]);
#2144    size_t index[MAX_RANK];
#2176            index[j] = 0;
#2177        err = nc_put_var1_text(BAD_IDiindex, &value);
#2180        err = nc_put_var1_text(ncidBAD_VARIDindex, &value);
#2185 index[j] = var_shape[i][j];
#2186 err = nc_put_var1_text(ncidiindex, &value);
#2189 index[j] = 0;
#2193            err = toMixedBase(jvar_rank[i], var_shape[i], index);
#2196            value = hash_textvar_type[i], var_rank[i], indexNCT_TEXT);
#2200 err = nc_put_var1_text(ncidiindex, &value);
#2238    size_t index[MAX_RANK];
#2270            index[j] = 0;
#2271        err = nc_put_var1_uchar(BAD_IDiindex, &value);
#2274        err = nc_put_var1_uchar(ncidBAD_VARIDindex, &value);
#2279 index[j] = var_shape[i][j];
#2280 err = nc_put_var1_uchar(ncidiindex, &value);
#2283 index[j] = 0;
#2287            err = toMixedBase(jvar_rank[i], var_shape[i], index);
#2290            value = hash_ucharvar_type[i], var_rank[i], indexNCT_UCHAR);
#2294 err = nc_put_var1_uchar(ncidiindex, &value);
#2332    size_t index[MAX_RANK];
#2364            index[j] = 0;
#2365        err = nc_put_var1_schar(BAD_IDiindex, &value);
#2368        err = nc_put_var1_schar(ncidBAD_VARIDindex, &value);
#2373 index[j] = var_shape[i][j];
#2374 err = nc_put_var1_schar(ncidiindex, &value);
#2377 index[j] = 0;
#2381            err = toMixedBase(jvar_rank[i], var_shape[i], index);
#2384            value = hash_scharvar_type[i], var_rank[i], indexNCT_SCHAR);
#2388 err = nc_put_var1_schar(ncidiindex, &value);
#2426    size_t index[MAX_RANK];
#2458            index[j] = 0;
#2459        err = nc_put_var1_short(BAD_IDiindex, &value);
#2462        err = nc_put_var1_short(ncidBAD_VARIDindex, &value);
#2467 index[j] = var_shape[i][j];
#2468 err = nc_put_var1_short(ncidiindex, &value);
#2471 index[j] = 0;
#2475            err = toMixedBase(jvar_rank[i], var_shape[i], index);
#2478            value = hash_shortvar_type[i], var_rank[i], indexNCT_SHORT);
#2482 err = nc_put_var1_short(ncidiindex, &value);
#2520    size_t index[MAX_RANK];
#2552            index[j] = 0;
#2553        err = nc_put_var1_int(BAD_IDiindex, &value);
#2556        err = nc_put_var1_int(ncidBAD_VARIDindex, &value);
#2561 index[j] = var_shape[i][j];
#2562 err = nc_put_var1_int(ncidiindex, &value);
#2565 index[j] = 0;
#2569            err = toMixedBase(jvar_rank[i], var_shape[i], index);
#2572            value = hash_intvar_type[i], var_rank[i], indexNCT_INT);
#2576 err = nc_put_var1_int(ncidiindex, &value);
#2614    size_t index[MAX_RANK];
#2646            index[j] = 0;
#2647        err = nc_put_var1_long(BAD_IDiindex, &value);
#2650        err = nc_put_var1_long(ncidBAD_VARIDindex, &value);
#2655 index[j] = var_shape[i][j];
#2656 err = nc_put_var1_long(ncidiindex, &value);
#2659 index[j] = 0;
#2663            err = toMixedBase(jvar_rank[i], var_shape[i], index);
#2666            value = hash_longvar_type[i], var_rank[i], indexNCT_LONG);
#2670 err = nc_put_var1_long(ncidiindex, &value);
#2708    size_t index[MAX_RANK];
#2740            index[j] = 0;
#2741        err = nc_put_var1_float(BAD_IDiindex, &value);
#2744        err = nc_put_var1_float(ncidBAD_VARIDindex, &value);
#2749 index[j] = var_shape[i][j];
#2750 err = nc_put_var1_float(ncidiindex, &value);
#2753 index[j] = 0;
#2757            err = toMixedBase(jvar_rank[i], var_shape[i], index);
#2760            value = hash_floatvar_type[i], var_rank[i], indexNCT_FLOAT);
#2764 err = nc_put_var1_float(ncidiindex, &value);
#2802    size_t index[MAX_RANK];
#2834            index[j] = 0;
#2835        err = nc_put_var1_double(BAD_IDiindex, &value);
#2838        err = nc_put_var1_double(ncidBAD_VARIDindex, &value);
#2843 index[j] = var_shape[i][j];
#2844 err = nc_put_var1_double(ncidiindex, &value);
#2847 index[j] = 0;
#2851            err = toMixedBase(jvar_rank[i], var_shape[i], index);
#2854            value = hash_doublevar_type[i], var_rank[i], indexNCT_DOUBLE);
#2858 err = nc_put_var1_double(ncidiindex, &value);
#2896    size_t index[MAX_RANK];
#2928            index[j] = 0;
#2929        err = nc_put_var1_ushort(BAD_IDiindex, &value);
#2932        err = nc_put_var1_ushort(ncidBAD_VARIDindex, &value);
#2937 index[j] = var_shape[i][j];
#2938 err = nc_put_var1_ushort(ncidiindex, &value);
#2941 index[j] = 0;
#2945            err = toMixedBase(jvar_rank[i], var_shape[i], index);
#2948            value = hash_ushortvar_type[i], var_rank[i], indexNCT_USHORT);
#2952 err = nc_put_var1_ushort(ncidiindex, &value);
#2990    size_t index[MAX_RANK];
#3022            index[j] = 0;
#3023        err = nc_put_var1_uint(BAD_IDiindex, &value);
#3026        err = nc_put_var1_uint(ncidBAD_VARIDindex, &value);
#3031 index[j] = var_shape[i][j];
#3032 err = nc_put_var1_uint(ncidiindex, &value);
#3035 index[j] = 0;
#3039            err = toMixedBase(jvar_rank[i], var_shape[i], index);
#3042            value = hash_uintvar_type[i], var_rank[i], indexNCT_UINT);
#3046 err = nc_put_var1_uint(ncidiindex, &value);
#3084    size_t index[MAX_RANK];
#3116            index[j] = 0;
#3117        err = nc_put_var1_longlong(BAD_IDiindex, &value);
#3120        err = nc_put_var1_longlong(ncidBAD_VARIDindex, &value);
#3125 index[j] = var_shape[i][j];
#3126 err = nc_put_var1_longlong(ncidiindex, &value);
#3129 index[j] = 0;
#3133            err = toMixedBase(jvar_rank[i], var_shape[i], index);
#3136            value = hash_longlongvar_type[i], var_rank[i], indexNCT_LONGLONG);
#3140 err = nc_put_var1_longlong(ncidiindex, &value);
#3178    size_t index[MAX_RANK];
#3210            index[j] = 0;
#3211        err = nc_put_var1_ulonglong(BAD_IDiindex, &value);
#3214        err = nc_put_var1_ulonglong(ncidBAD_VARIDindex, &value);
#3219 index[j] = var_shape[i][j];
#3220 err = nc_put_var1_ulonglong(ncidiindex, &value);
#3223 index[j] = 0;
#3227            err = toMixedBase(jvar_rank[i], var_shape[i], index);
#3230            value = hash_ulonglongvar_type[i], var_rank[i], indexNCT_ULONGLONG);
#3234 err = nc_put_var1_ulonglong(ncidiindex, &value);
#3277    size_t index[MAX_RANK];
#3323     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#3326     value[j]= hash_text(var_type[i], var_rank[i], indexNCT_TEXT);
#3353    index[0] = NRECS-1;
#3354    err = nc_put_var1_text(ncidvaridindex, "x");
#3371 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#3374 value[j]= hash_text(var_type[i], var_rank[i], indexNCT_TEXT);
#3414    size_t index[MAX_RANK];
#3460     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#3463     value[j]= hash_uchar(var_type[i], var_rank[i], indexNCT_UCHAR);
#3490    index[0] = NRECS-1;
#3491    err = nc_put_var1_text(ncidvaridindex, "x");
#3508 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#3511 value[j]= hash_uchar(var_type[i], var_rank[i], indexNCT_UCHAR);
#3551    size_t index[MAX_RANK];
#3597     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#3600     value[j]= hash_schar(var_type[i], var_rank[i], indexNCT_SCHAR);
#3627    index[0] = NRECS-1;
#3628    err = nc_put_var1_text(ncidvaridindex, "x");
#3645 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#3648 value[j]= hash_schar(var_type[i], var_rank[i], indexNCT_SCHAR);
#3688    size_t index[MAX_RANK];
#3734     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#3737     value[j]= hash_short(var_type[i], var_rank[i], indexNCT_SHORT);
#3764    index[0] = NRECS-1;
#3765    err = nc_put_var1_text(ncidvaridindex, "x");
#3782 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#3785 value[j]= hash_short(var_type[i], var_rank[i], indexNCT_SHORT);
#3825    size_t index[MAX_RANK];
#3871     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#3874     value[j]= hash_int(var_type[i], var_rank[i], indexNCT_INT);
#3901    index[0] = NRECS-1;
#3902    err = nc_put_var1_text(ncidvaridindex, "x");
#3919 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#3922 value[j]= hash_int(var_type[i], var_rank[i], indexNCT_INT);
#3962    size_t index[MAX_RANK];
#4008     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#4011     value[j]= hash_long(var_type[i], var_rank[i], indexNCT_LONG);
#4038    index[0] = NRECS-1;
#4039    err = nc_put_var1_text(ncidvaridindex, "x");
#4056 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#4059 value[j]= hash_long(var_type[i], var_rank[i], indexNCT_LONG);
#4099    size_t index[MAX_RANK];
#4145     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#4148     value[j]= hash_float(var_type[i], var_rank[i], indexNCT_FLOAT);
#4175    index[0] = NRECS-1;
#4176    err = nc_put_var1_text(ncidvaridindex, "x");
#4193 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#4196 value[j]= hash_float(var_type[i], var_rank[i], indexNCT_FLOAT);
#4236    size_t index[MAX_RANK];
#4282     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#4285     value[j]= hash_double(var_type[i], var_rank[i], indexNCT_DOUBLE);
#4312    index[0] = NRECS-1;
#4313    err = nc_put_var1_text(ncidvaridindex, "x");
#4330 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#4333 value[j]= hash_double(var_type[i], var_rank[i], indexNCT_DOUBLE);
#4373    size_t index[MAX_RANK];
#4419     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#4422     value[j]= hash_ushort(var_type[i], var_rank[i], indexNCT_USHORT);
#4449    index[0] = NRECS-1;
#4450    err = nc_put_var1_text(ncidvaridindex, "x");
#4467 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#4470 value[j]= hash_ushort(var_type[i], var_rank[i], indexNCT_USHORT);
#4510    size_t index[MAX_RANK];
#4556     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#4559     value[j]= hash_uint(var_type[i], var_rank[i], indexNCT_UINT);
#4586    index[0] = NRECS-1;
#4587    err = nc_put_var1_text(ncidvaridindex, "x");
#4604 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#4607 value[j]= hash_uint(var_type[i], var_rank[i], indexNCT_UINT);
#4647    size_t index[MAX_RANK];
#4693     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#4696     value[j]= hash_longlong(var_type[i], var_rank[i], indexNCT_LONGLONG);
#4723    index[0] = NRECS-1;
#4724    err = nc_put_var1_text(ncidvaridindex, "x");
#4741 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#4744 value[j]= hash_longlong(var_type[i], var_rank[i], indexNCT_LONGLONG);
#4784    size_t index[MAX_RANK];
#4830     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#4833     value[j]= hash_ulonglong(var_type[i], var_rank[i], indexNCT_ULONGLONG);
#4860    index[0] = NRECS-1;
#4861    err = nc_put_var1_text(ncidvaridindex, "x");
#4878 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#4881 value[j]= hash_ulonglong(var_type[i], var_rank[i], indexNCT_ULONGLONG);
#4929    size_t index[MAX_RANK];
#5027 err = toMixedBase(jvar_rank[i], edgeindex);
#5031     index[d] += start[d];
#5032 value[j]= hash_text(var_type[i], var_rank[i], indexNCT_TEXT);
#5080    size_t index[MAX_RANK];
#5178 err = toMixedBase(jvar_rank[i], edgeindex);
#5182     index[d] += start[d];
#5183 value[j]= hash_uchar(var_type[i], var_rank[i], indexNCT_UCHAR);
#5231    size_t index[MAX_RANK];
#5329 err = toMixedBase(jvar_rank[i], edgeindex);
#5333     index[d] += start[d];
#5334 value[j]= hash_schar(var_type[i], var_rank[i], indexNCT_SCHAR);
#5382    size_t index[MAX_RANK];
#5480 err = toMixedBase(jvar_rank[i], edgeindex);
#5484     index[d] += start[d];
#5485 value[j]= hash_short(var_type[i], var_rank[i], indexNCT_SHORT);
#5533    size_t index[MAX_RANK];
#5631 err = toMixedBase(jvar_rank[i], edgeindex);
#5635     index[d] += start[d];
#5636 value[j]= hash_int(var_type[i], var_rank[i], indexNCT_INT);
#5684    size_t index[MAX_RANK];
#5782 err = toMixedBase(jvar_rank[i], edgeindex);
#5786     index[d] += start[d];
#5787 value[j]= hash_long(var_type[i], var_rank[i], indexNCT_LONG);
#5835    size_t index[MAX_RANK];
#5933 err = toMixedBase(jvar_rank[i], edgeindex);
#5937     index[d] += start[d];
#5938 value[j]= hash_float(var_type[i], var_rank[i], indexNCT_FLOAT);
#5986    size_t index[MAX_RANK];
#6084 err = toMixedBase(jvar_rank[i], edgeindex);
#6088     index[d] += start[d];
#6089 value[j]= hash_double(var_type[i], var_rank[i], indexNCT_DOUBLE);
#6137    size_t index[MAX_RANK];
#6235 err = toMixedBase(jvar_rank[i], edgeindex);
#6239     index[d] += start[d];
#6240 value[j]= hash_ushort(var_type[i], var_rank[i], indexNCT_USHORT);
#6288    size_t index[MAX_RANK];
#6386 err = toMixedBase(jvar_rank[i], edgeindex);
#6390     index[d] += start[d];
#6391 value[j]= hash_uint(var_type[i], var_rank[i], indexNCT_UINT);
#6439    size_t index[MAX_RANK];
#6537 err = toMixedBase(jvar_rank[i], edgeindex);
#6541     index[d] += start[d];
#6542 value[j]= hash_longlong(var_type[i], var_rank[i], indexNCT_LONGLONG);
#6590    size_t index[MAX_RANK];
#6688 err = toMixedBase(jvar_rank[i], edgeindex);
#6692     index[d] += start[d];
#6693 value[j]= hash_ulonglong(var_type[i], var_rank[i], indexNCT_ULONGLONG);
#6745    size_t index[MAX_RANK];
#6842 err = toMixedBase(mvar_rank[i], sstrideindex);
#6847     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#6849     index[j] += start[j];
#6865 index2[d] = index[d] + index2[d] * stride[d];
#6874     err = nc_put_vars_text(ncidiindexcountstridevalue);
#6917    size_t index[MAX_RANK];
#7014 err = toMixedBase(mvar_rank[i], sstrideindex);
#7019     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7021     index[j] += start[j];
#7037 index2[d] = index[d] + index2[d] * stride[d];
#7046     err = nc_put_vars_uchar(ncidiindexcountstridevalue);
#7089    size_t index[MAX_RANK];
#7186 err = toMixedBase(mvar_rank[i], sstrideindex);
#7191     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7193     index[j] += start[j];
#7209 index2[d] = index[d] + index2[d] * stride[d];
#7218     err = nc_put_vars_schar(ncidiindexcountstridevalue);
#7261    size_t index[MAX_RANK];
#7358 err = toMixedBase(mvar_rank[i], sstrideindex);
#7363     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7365     index[j] += start[j];
#7381 index2[d] = index[d] + index2[d] * stride[d];
#7390     err = nc_put_vars_short(ncidiindexcountstridevalue);
#7433    size_t index[MAX_RANK];
#7530 err = toMixedBase(mvar_rank[i], sstrideindex);
#7535     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7537     index[j] += start[j];
#7553 index2[d] = index[d] + index2[d] * stride[d];
#7562     err = nc_put_vars_int(ncidiindexcountstridevalue);
#7605    size_t index[MAX_RANK];
#7702 err = toMixedBase(mvar_rank[i], sstrideindex);
#7707     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7709     index[j] += start[j];
#7725 index2[d] = index[d] + index2[d] * stride[d];
#7734     err = nc_put_vars_long(ncidiindexcountstridevalue);
#7777    size_t index[MAX_RANK];
#7874 err = toMixedBase(mvar_rank[i], sstrideindex);
#7879     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#7881     index[j] += start[j];
#7897 index2[d] = index[d] + index2[d] * stride[d];
#7906     err = nc_put_vars_float(ncidiindexcountstridevalue);
#7949    size_t index[MAX_RANK];
#8046 err = toMixedBase(mvar_rank[i], sstrideindex);
#8051     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#8053     index[j] += start[j];
#8069 index2[d] = index[d] + index2[d] * stride[d];
#8078     err = nc_put_vars_double(ncidiindexcountstridevalue);
#8121    size_t index[MAX_RANK];
#8218 err = toMixedBase(mvar_rank[i], sstrideindex);
#8223     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#8225     index[j] += start[j];
#8241 index2[d] = index[d] + index2[d] * stride[d];
#8250     err = nc_put_vars_ushort(ncidiindexcountstridevalue);
#8293    size_t index[MAX_RANK];
#8390 err = toMixedBase(mvar_rank[i], sstrideindex);
#8395     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#8397     index[j] += start[j];
#8413 index2[d] = index[d] + index2[d] * stride[d];
#8422     err = nc_put_vars_uint(ncidiindexcountstridevalue);
#8465    size_t index[MAX_RANK];
#8562 err = toMixedBase(mvar_rank[i], sstrideindex);
#8567     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#8569     index[j] += start[j];
#8585 index2[d] = index[d] + index2[d] * stride[d];
#8594     err = nc_put_vars_longlong(ncidiindexcountstridevalue);
#8637    size_t index[MAX_RANK];
#8734 err = toMixedBase(mvar_rank[i], sstrideindex);
#8739     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#8741     index[j] += start[j];
#8757 index2[d] = index[d] + index2[d] * stride[d];
#8766     err = nc_put_vars_ulonglong(ncidiindexcountstridevalue);
#8812    size_t index[MAX_RANK];
#8911                err = toMixedBase(mvar_rank[i], sstrideindex);
#8916                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#8918                    index[j] += start[j];
#8940                        index2[d] = index[d] + index2[d] * stride[d];
#8949                    err = nc_put_varm_text(ncid,i,index,count,stride,imap,value);
#8992    size_t index[MAX_RANK];
#9091                err = toMixedBase(mvar_rank[i], sstrideindex);
#9096                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#9098                    index[j] += start[j];
#9120                        index2[d] = index[d] + index2[d] * stride[d];
#9129                    err = nc_put_varm_uchar(ncid,i,index,count,stride,imap,value);
#9172    size_t index[MAX_RANK];
#9271                err = toMixedBase(mvar_rank[i], sstrideindex);
#9276                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#9278                    index[j] += start[j];
#9300                        index2[d] = index[d] + index2[d] * stride[d];
#9309                    err = nc_put_varm_schar(ncid,i,index,count,stride,imap,value);
#9352    size_t index[MAX_RANK];
#9451                err = toMixedBase(mvar_rank[i], sstrideindex);
#9456                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#9458                    index[j] += start[j];
#9480                        index2[d] = index[d] + index2[d] * stride[d];
#9489                    err = nc_put_varm_short(ncid,i,index,count,stride,imap,value);
#9532    size_t index[MAX_RANK];
#9631                err = toMixedBase(mvar_rank[i], sstrideindex);
#9636                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#9638                    index[j] += start[j];
#9660                        index2[d] = index[d] + index2[d] * stride[d];
#9669                    err = nc_put_varm_int(ncid,i,index,count,stride,imap,value);
#9712    size_t index[MAX_RANK];
#9811                err = toMixedBase(mvar_rank[i], sstrideindex);
#9816                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#9818                    index[j] += start[j];
#9840                        index2[d] = index[d] + index2[d] * stride[d];
#9849                    err = nc_put_varm_long(ncid,i,index,count,stride,imap,value);
#9892    size_t index[MAX_RANK];
#9991                err = toMixedBase(mvar_rank[i], sstrideindex);
#9996                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#9998                    index[j] += start[j];
#10020                        index2[d] = index[d] + index2[d] * stride[d];
#10029                    err = nc_put_varm_float(ncid,i,index,count,stride,imap,value);
#10072    size_t index[MAX_RANK];
#10171                err = toMixedBase(mvar_rank[i], sstrideindex);
#10176                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#10178                    index[j] += start[j];
#10200                        index2[d] = index[d] + index2[d] * stride[d];
#10209                    err = nc_put_varm_double(ncid,i,index,count,stride,imap,value);
#10252    size_t index[MAX_RANK];
#10351                err = toMixedBase(mvar_rank[i], sstrideindex);
#10356                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#10358                    index[j] += start[j];
#10380                        index2[d] = index[d] + index2[d] * stride[d];
#10389                    err = nc_put_varm_ushort(ncid,i,index,count,stride,imap,value);
#10432    size_t index[MAX_RANK];
#10531                err = toMixedBase(mvar_rank[i], sstrideindex);
#10536                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#10538                    index[j] += start[j];
#10560                        index2[d] = index[d] + index2[d] * stride[d];
#10569                    err = nc_put_varm_uint(ncid,i,index,count,stride,imap,value);
#10612    size_t index[MAX_RANK];
#10711                err = toMixedBase(mvar_rank[i], sstrideindex);
#10716                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#10718                    index[j] += start[j];
#10740                        index2[d] = index[d] + index2[d] * stride[d];
#10749                    err = nc_put_varm_longlong(ncid,i,index,count,stride,imap,value);
#10792    size_t index[MAX_RANK];
#10891                err = toMixedBase(mvar_rank[i], sstrideindex);
#10896                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#10898                    index[j] += start[j];
#10920                        index2[d] = index[d] + index2[d] * stride[d];
#10929                    err = nc_put_varm_ulonglong(ncid,i,index,count,stride,imap,value);
test_read.c#840    size_t index[MAX_RANK];
#851     index[j] = 0;
#852        err = nc_get_var1(BAD_IDiindexbuf);
#855        err = nc_get_var1(ncidBAD_VARIDindexbuf);
#859     index[j] = var_shape[i][j];
#860     err = nc_get_var1(ncidiindexbuf);
#863     index[j] = 0;
#866     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#869     expect = hashvar_type[i], var_rank[i], index );
#873 err = nc_get_var1(ncidiindexbuf);
#914    size_t index[MAX_RANK];
#982     err = toMixedBase(jvar_rank[i], edgeindex);
#986 index[d] += start[d];
#987     expect = hash(var_type[i], var_rank[i], index);
#1037    size_t index[MAX_RANK];
#1106 err = toMixedBase(mvar_rank[i], sstrideindex);
#1111     count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#1113     index[j] += start[j];
#1127     err = nc_get_vars(ncidiindexcountstridebuf);
#1141     index2[d] = index[d] + index2[d] * stride[d];
#1203    size_t index[MAX_RANK];
#1283     err = toMixedBase(mvar_rank[i], sstrideindex);
#1287 count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#1288 index[j] += start[j];
#1299     j = fromMixedBase(var_rank[i], indexvar_shape[i]);
#1301     err = nc_get_varm(ncidiindexcountstrideimap2p);
#1309            err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1312            expect = hashvar_type[i], var_rank[i], index);
test_vara.c#38    size_t* index;
#153    odom->index = (size_t*)calloc(sizeof(size_t)*rank,1);
#162    free(odom->index);
#179        odom->index[i] = odom->start[i];
#186    return (odom->index[0] < odom->stop[0]?1:0);
#194        odom->index[i]++;
#195        if(odom->index[i] < odom->stop[i]) break;
#197 odom->index[i] = odom->start[i]; /* reset this position*/
#209 offset += odom->index[i];
test_write.c#716    size_t index[MAX_RANK];
#733            index[j] = 0;
#734        err = nc_put_var1(BAD_IDiindexbuf);
#737        err = nc_put_var1(ncidBAD_VARIDindexbuf);
#742                index[j] = var_shape[i][j];
#743                err = nc_put_var1(ncidiindexbuf);
#746                index[j] = 0;
#750            err = toMixedBase(jvar_rank[i], var_shape[i], index);
#753            value = hashvar_type[i], var_rank[i], index);
#761     err = nc_put_var1(ncidiindexbuf);
#799    size_t index[MAX_RANK];
#865 err = toMixedBase(jvar_rank[i], edgeindex);
#869     index[d] += start[d];
#870 value = hashvar_type[i], var_rank[i], index);
#922    size_t index[MAX_RANK];
#999                err = toMixedBase(mvar_rank[i], sstrideindex);
#1004                    count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#1006                    index[j] += start[j];
#1023 index2[d] = index[d] + index2[d] * stride[d];
#1035     err = nc_put_vars(ncidiindexcountstridebuf);
#1076    size_t index[MAX_RANK];
#1115     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1118     value = hashvar_type[i], var_rank[i], index);
#1178     err = toMixedBase(mvar_rank[i], sstrideindex);
#1182 count[j] = 1 + (edge[j] - index[j] - 1) / stride[j];
#1183 index[j] += start[j];
#1194     j = fromMixedBase(var_rank[i], indexvar_shape[i]);
#1196     err = nc_put_varm(ncidiindexcountstrideimap2p);
#1811    size_t index[MAX_RANK];
#1872    index[0] = NRECS;
#1873    err = nc_put_var1_text(ncidvaridindex, &text);
#1889            err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1893 err = nc_get_var1_text(ncidiindex, &text);
#1898 err = nc_get_var1_double(ncidiindex, &value);
#1940    index[0] = NRECS;
#1941    err = nc_put_var1_text(ncidvaridindex, &text);
#1948            err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1952 err = nc_get_var1_text(ncidiindex, &text);
#1957 err = nc_get_var1_double(ncidiindex, &value);
tests.h#536double hash( const nc_type type, const int rank, const size_t *index );
#541    const size_t *index,
tst_big_rvar.c#44    size_t index[NUMDIMS];
tst_big_var.c#42    size_t index[NUMDIMS];
#53    index[0] = DIM1 - 1;
#54    index[1] = DIM2 - 2;
#55    if (nc_put_var1_int(ncidvaridindex, &nval)) ERR;
#61    if (nc_get_var1_int(ncidvaridindex, &nval_in)) ERR;
tst_big_var2.c#48    size_t index[NUMDIMS];
tst_comp.c#143       size_t index[VAR6_RANK];
#144       index[0] = i;
#145       if (nc_get_var1(ncidvaridindex, (void *) &val_in)) ERR;
tst_comp2.c#154       size_t index[VAR_RANK];
#155       index[0] = k;
#156       if (nc_get_var1(ncidvaridindex, (void *) &val_in)) ERR;
tst_compounds.c#731  size_t index[VAR6_RANK];
#732  index[0] = i;
#733  if (nc_get_var1(ncidvaridindex, (void *) &val_in)) ERR;
#814  size_t index[VAR6_RANK];
#815  index[0] = i;
#816  if (nc_get_var1(ncidvaridindex, (void *) &val_in)) ERR;
tst_dims.c#619      size_t start[MAX_DIMS], count[MAX_DIMS], index[MAX_DIMS];
#654      index[0] = 0;
#655      if (nc_get_var1_ushort(ncidhp_varidindexdata_in)) ERR;
tst_dims2.c#355      size_t index[NDIMS], count[NDIMS], len_in;
#376      index[0] = 0;
#377      index[1] = 0;
#380      if (nc_put_vara_text(ncidvaridindexcountttext)) ERR;
#401      index[1] = 0;
#404      for (index[0] = 1; index[0] < NUM_RECSindex[0]++)
#405  if (nc_put_vara_text(ncidvaridindexcountttext)) ERR;
tst_diskless3.c#53   size_t start[ONE_DIM], count[ONE_DIM], index[ONE_DIM], len_in;
#90      index[0] = r;
#93  if((status=nc_get_var1_text(ncidvarid[v], index, &data_in))) ERRSTAT(status);
tst_files.c#322      size_t count[NDIMS], index[NDIMS] = {0};
#341  if (nc_put_vara_text(ncid[f], varidindexcountttext)) ERR;
#347  if (nc_get_vara_text(ncid[f], varidindexcount, (char *)ttext_in)) ERR;
tst_fills2.c#41      size_t index = DATA_START;
#55      if (nc_put_var1_string(ncidvarid_in, &indexdata_out)) ERR;
#58      if (nc_get_var1_string(ncidvarid_in, &index, &data_in)) ERR;
#68      if (nc_get_var1_string(ncidvarid_in, &index, &data_in)) ERR;
#98      size_t index = DATA_START;
#118      if (nc_put_var1_string(ncidvarid_in, &indexdata_out)) ERR;
#121      index = 0;
#123      if (nc_get_var1_string(ncidvarid_in, &index, &data_in)) ERR;
#126      index = 1;
#128      if (nc_get_var1_string(ncidvarid_in, &index, &data_in)) ERR;
#131      index = DATA_START;
#133      if (nc_get_var1_string(ncidvarid_in, &index, &data_in)) ERR;
#153      index = 0;
#155      if (nc_get_var1_string(ncidvarid_in, &index, &data_in)) ERR;
#158      index = 1;
#160      if (nc_get_var1_string(ncidvarid_in, &index, &data_in)) ERR;
#164      index = DATA_START;
#166      if (nc_get_var1_string(ncidvarid_in, &index, &data_in)) ERR;
#189      size_t index = DATA_START;
#206      if (nc_put_var1_string(ncidvarid_in, &indexdata_out)) ERR;
#257      size_t index = DATA_START2;
#275      if (nc_put_var1_string(ncidvarid_in, &indexdata_out)) ERR;
tst_grps.c#111      size_t len_inindex[NDIMS_IN_VAR] = {0};
#151      if (nc_put_var1_longlong(grpid_invarid_in1index, &value)) ERR;
#155      if (nc_get_var1_longlong(grpid_invarid_in2index, &value_in)) ERR;
#160      if (nc_get_var1_longlong(grpid_invarid_in3index, &value_in)) ERR;
#164      index[0] = BABE_LIMIT;
#165      if (nc_get_var1_longlong(grpid_invarid_in1index, &value_in) != NC_EINVALCOORDSERR;
#166      if (nc_get_var1_longlong(grpid_invarid_in2index, &value_in) != NC_EINVALCOORDSERR;
#167      if (nc_get_var1_longlong(grpid_invarid_in3index, &value_in) != NC_EINVALCOORDSERR;
#202      index[0] = 0;
#203      if (nc_get_var1_longlong(grpid_invarid_in2index, &value_in)) ERR;
#208      if (nc_get_var1_longlong(grpid_invarid_in3index, &value_in)) ERR;
#212      index[0] = BABE_LIMIT;
#213      if (nc_get_var1_longlong(grpid_invarid_in1index, &value_in) != NC_EINVALCOORDSERR;
#214      if (nc_get_var1_longlong(grpid_invarid_in2index, &value_in) != NC_EINVALCOORDSERR;
#215      if (nc_get_var1_longlong(grpid_invarid_in3index, &value_in) != NC_EINVALCOORDSERR;
tst_grps2.c#48      size_t len_inindex[NDIMS_IN_VAR] = {0};
#88      if (nc_put_var1_longlong(grpid_invarid_in1index, &value)) ERR;
#92      if (nc_get_var1_longlong(grpid_invarid_in2index, &value_in)) ERR;
#97      if (nc_get_var1_longlong(grpid_invarid_in3index, &value_in)) ERR;
#101      index[0] = BABE_LIMIT;
#102      if (nc_get_var1_longlong(grpid_invarid_in1index, &value_in) != NC_EINVALCOORDSERR;
#103      if (nc_get_var1_longlong(grpid_invarid_in2index, &value_in) != NC_EINVALCOORDSERR;
#104      if (nc_get_var1_longlong(grpid_invarid_in3index, &value_in) != NC_EINVALCOORDSERR;
#139      index[0] = 0;
#140      if (nc_get_var1_longlong(grpid_invarid_in2index, &value_in)) ERR;
#145      if (nc_get_var1_longlong(grpid_invarid_in3index, &value_in)) ERR;
#149      index[0] = BABE_LIMIT;
#150      if (nc_get_var1_longlong(grpid_invarid_in1index, &value_in) != NC_EINVALCOORDSERR;
#151      if (nc_get_var1_longlong(grpid_invarid_in2index, &value_in) != NC_EINVALCOORDSERR;
#152      if (nc_get_var1_longlong(grpid_invarid_in3index, &value_in) != NC_EINVALCOORDSERR;
tst_interops.c#123      size_t index[2];
#142      index[0] = index[1] = 0;
#143      if (nc_put_var1_float(ncidvarid_inindex, &new_float)) ERR;
tst_large.c#42    size_t index[NUMDIMS];
#55    index[0] = DIM1 - 1;
#56    index[1] = DIM2 - 2;
#57    if (nc_put_var1_schar(ncidvaridindex, &nval)) ERR;
#63    if (nc_get_var1_int(ncidvaridindex, &nval_in)) ERR;
#73    size_t index[NUMDIMS] = {0, 0};
#103    if (nc_get_var1_schar(ncidvaridindex, &char_val_in)) ERR;
#114    size_t index[2];
#122    index[0] = 0;
#123    index[1] = 1;
#124    if (nc_put_var1_int(ncidvaridindex, &int_val_out)) ERR;
#128    if (nc_get_var1_int(ncidvaridindex, &int_val_in)) ERR;
#132    index[0] = 1;
#133    index[1] = 2;
#134    if (nc_get_var1_int(ncidvaridindex, &int_val_in)) ERR;
tst_large.c#29      size_t index[NUMDIMS] = {0, 0};
tst_opaque_data.c#94       size_t index[VAR3_RANK];
#95       index[0] = i;
#96       if(nc_get_var1(ncidvaridindexval_in)) ERR;
tst_small.c#278   size_t start[ONE_DIM], count[ONE_DIM], index[ONE_DIM], len_in;
#323  index[0] = r;
#324  if (nc_get_var1_text(ncid, 0, index, &data_in)) ERR;
#343   size_t start[ONE_DIM], count[ONE_DIM], index[ONE_DIM], len_in;
#378      index[0] = r;
#379      if (nc_get_var1_text(ncid, 0, index, &data_in)) ERR;
#399   size_t start[ONE_DIM], count[ONE_DIM], index[ONE_DIM], len_in;
#445      index[0] = r;
#448  if (nc_get_var1_text(ncidvarid[v], index, &data_in)) ERR;
tst_vars.c#1026      size_t index[NDIMS];
#1054      index[0] = 1;
#1055      if (nc_put_var1_ushort(ncid, 0, index, &ushort_data)) ERR;
#1059      index[0] = 0;
#1060      if (nc_get_var1_ushort(ncid, 0, index, &ushort_data_in)) ERR;
#1086      size_t index[NDIMS];
#1103      index[0] = 1;
#1104      if (nc_put_var1_ushort(ncidvaridindex, &ushort_data)) ERR;
#1108      index[0] = 0;
#1109      if (nc_get_var1_ushort(ncidvaridindex, &ushort_data_in)) ERR;
#1136      size_t index[ND1];
#1153      index[0] = D1_TARGET;
#1154      index[1] = D2_TARGET;
#1155      if (nc_put_var1_int(ncidvaridindex, &data)) ERR;
tst_vars3.c#329      size_t index = 0;
#343      if ( nc_put_var1(grpidcVarId, &index, &s1Data) ) ERR;
tst_vlen_data.c#122       size_t index[VAR5_RANK];
#124       index[0] = i;
#125       if (nc_get_var1(ncidvaridindex, (void *) &val_in)) ERR;
util.c#377hash( const nc_type type, const int rank, const size_t *index )
#385    if (abs(rank) == 1 && index[0] <= 3) {
#386 switch (index[0]) {
#470     result = base * (result + index[d]);
#482hash( const nc_type type, const int rank, const size_t *index )
#490    if (abs(rank) == 1 && index[0] <= 3) {
#491 switch (index[0]) {
#575     result = base * (result + index[d]);
#585    const size_t *index,
#590    result = hashtyperankindex );
#820    size_t index[MAX_RANK];
#832     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#835 text[j] = hash(var_type[i], var_rank[i], index);
#837 value[j]  = hash(var_type[i], var_rank[i], index);
#924    size_t index[MAX_RANK];
#958     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#961     expect = hashvar_type[i], var_rank[i], index );
#963          err = nc_get_var1_text(ncidiindex, &text);
#969 print_n_size_t(var_rank[i], index);
#973 print_n_size_t(var_rank[i], index);
#978 err = nc_get_var1_double(ncidiindex, &value);
#985        err = nc_get_var1_double(ncidiindex, &value);
#988     print_n_size_t(var_rank[i], index);
#992 print_n_size_t(var_rank[i], index);


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