nc_test.c#38size_t var_rank[NVARS];
test_get.c#34 for (j = 0; j < var_rank[i]; j++)
#42 for (j = 0; j < var_rank[i]; j++) {
#53     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#56     expect = hash4var_type[i], var_rank[i], indexNCT_TEXT );
#57     if (var_rank[i] == 0 && i%2 )
#112 for (j = 0; j < var_rank[i]; j++)
#120 for (j = 0; j < var_rank[i]; j++) {
#131     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#134     expect = hash4var_type[i], var_rank[i], indexNCT_UCHAR );
#135     if (var_rank[i] == 0 && i%2 )
#190 for (j = 0; j < var_rank[i]; j++)
#198 for (j = 0; j < var_rank[i]; j++) {
#209     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#212     expect = hash4var_type[i], var_rank[i], indexNCT_SCHAR );
#213     if (var_rank[i] == 0 && i%2 )
#268 for (j = 0; j < var_rank[i]; j++)
#276 for (j = 0; j < var_rank[i]; j++) {
#287     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#290     expect = hash4var_type[i], var_rank[i], indexNCT_SHORT );
#291     if (var_rank[i] == 0 && i%2 )
#346 for (j = 0; j < var_rank[i]; j++)
#354 for (j = 0; j < var_rank[i]; j++) {
#365     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#368     expect = hash4var_type[i], var_rank[i], indexNCT_INT );
#369     if (var_rank[i] == 0 && i%2 )
#424 for (j = 0; j < var_rank[i]; j++)
#432 for (j = 0; j < var_rank[i]; j++) {
#443     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#446     expect = hash4var_type[i], var_rank[i], indexNCT_LONG );
#447     if (var_rank[i] == 0 && i%2 )
#502 for (j = 0; j < var_rank[i]; j++)
#510 for (j = 0; j < var_rank[i]; j++) {
#521     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#524     expect = hash4var_type[i], var_rank[i], indexNCT_FLOAT );
#525     if (var_rank[i] == 0 && i%2 )
#580 for (j = 0; j < var_rank[i]; j++)
#588 for (j = 0; j < var_rank[i]; j++) {
#599     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#602     expect = hash4var_type[i], var_rank[i], indexNCT_DOUBLE );
#603     if (var_rank[i] == 0 && i%2 )
#658 for (j = 0; j < var_rank[i]; j++)
#666 for (j = 0; j < var_rank[i]; j++) {
#677     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#680     expect = hash4var_type[i], var_rank[i], indexNCT_USHORT );
#681     if (var_rank[i] == 0 && i%2 )
#736 for (j = 0; j < var_rank[i]; j++)
#744 for (j = 0; j < var_rank[i]; j++) {
#755     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#758     expect = hash4var_type[i], var_rank[i], indexNCT_UINT );
#759     if (var_rank[i] == 0 && i%2 )
#814 for (j = 0; j < var_rank[i]; j++)
#822 for (j = 0; j < var_rank[i]; j++) {
#833     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#836     expect = hash4var_type[i], var_rank[i], indexNCT_LONGLONG );
#837     if (var_rank[i] == 0 && i%2 )
#892 for (j = 0; j < var_rank[i]; j++)
#900 for (j = 0; j < var_rank[i]; j++) {
#911     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#914     expect = hash4var_type[i], var_rank[i], indexNCT_ULONGLONG );
#915     if (var_rank[i] == 0 && i%2 )
#976        assert(var_rank[i] <= MAX_RANK);
#986 for (j = 0; j < var_rank[i]; j++) {
#991     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#994     expect[j] = hash4(var_type[i], var_rank[i], indexNCT_TEXT);
#1066        assert(var_rank[i] <= MAX_RANK);
#1076 for (j = 0; j < var_rank[i]; j++) {
#1081     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1084     expect[j] = hash4(var_type[i], var_rank[i], indexNCT_UCHAR);
#1156        assert(var_rank[i] <= MAX_RANK);
#1166 for (j = 0; j < var_rank[i]; j++) {
#1171     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1174     expect[j] = hash4(var_type[i], var_rank[i], indexNCT_SCHAR);
#1246        assert(var_rank[i] <= MAX_RANK);
#1256 for (j = 0; j < var_rank[i]; j++) {
#1261     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1264     expect[j] = hash4(var_type[i], var_rank[i], indexNCT_SHORT);
#1336        assert(var_rank[i] <= MAX_RANK);
#1346 for (j = 0; j < var_rank[i]; j++) {
#1351     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1354     expect[j] = hash4(var_type[i], var_rank[i], indexNCT_INT);
#1426        assert(var_rank[i] <= MAX_RANK);
#1436 for (j = 0; j < var_rank[i]; j++) {
#1441     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1444     expect[j] = hash4(var_type[i], var_rank[i], indexNCT_LONG);
#1516        assert(var_rank[i] <= MAX_RANK);
#1526 for (j = 0; j < var_rank[i]; j++) {
#1531     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1534     expect[j] = hash4(var_type[i], var_rank[i], indexNCT_FLOAT);
#1606        assert(var_rank[i] <= MAX_RANK);
#1616 for (j = 0; j < var_rank[i]; j++) {
#1621     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1624     expect[j] = hash4(var_type[i], var_rank[i], indexNCT_DOUBLE);
#1696        assert(var_rank[i] <= MAX_RANK);
#1706 for (j = 0; j < var_rank[i]; j++) {
#1711     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1714     expect[j] = hash4(var_type[i], var_rank[i], indexNCT_USHORT);
#1786        assert(var_rank[i] <= MAX_RANK);
#1796 for (j = 0; j < var_rank[i]; j++) {
#1801     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1804     expect[j] = hash4(var_type[i], var_rank[i], indexNCT_UINT);
#1876        assert(var_rank[i] <= MAX_RANK);
#1886 for (j = 0; j < var_rank[i]; j++) {
#1891     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1894     expect[j] = hash4(var_type[i], var_rank[i], indexNCT_LONGLONG);
#1966        assert(var_rank[i] <= MAX_RANK);
#1976 for (j = 0; j < var_rank[i]; j++) {
#1981     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1984     expect[j] = hash4(var_type[i], var_rank[i], indexNCT_ULONGLONG);
#2065        assert(var_rank[i] <= MAX_RANK);
#2067 for (j = 0; j < var_rank[i]; j++) {
#2077 for (j = 0; j < var_rank[i]; j++) {
#2091 if(var_rank[i] > 0) {
#2092     for (j = 0; j < var_rank[i]; j++) {
#2109     for (j = 0; j < var_rank[i]; j++) {
#2115        for (j = 0; j < var_rank[i]; j++) {
#2122            for (j = 0; j < var_rank[i]; j++) {
#2134                err = toMixedBase(jvar_rank[i], edgeindex);
#2137                for (d = 0; d < var_rank[i]; d++)
#2139                expect[j] = hash4(var_type[i], var_rank[i], indexNCT_TEXT);
#2147            if (var_rank[i] == 0 && i%2)
#2221        assert(var_rank[i] <= MAX_RANK);
#2223 for (j = 0; j < var_rank[i]; j++) {
#2233 for (j = 0; j < var_rank[i]; j++) {
#2247 if(var_rank[i] > 0) {
#2248     for (j = 0; j < var_rank[i]; j++) {
#2265     for (j = 0; j < var_rank[i]; j++) {
#2271        for (j = 0; j < var_rank[i]; j++) {
#2278            for (j = 0; j < var_rank[i]; j++) {
#2290                err = toMixedBase(jvar_rank[i], edgeindex);
#2293                for (d = 0; d < var_rank[i]; d++)
#2295                expect[j] = hash4(var_type[i], var_rank[i], indexNCT_UCHAR);
#2303            if (var_rank[i] == 0 && i%2)
#2377        assert(var_rank[i] <= MAX_RANK);
#2379 for (j = 0; j < var_rank[i]; j++) {
#2389 for (j = 0; j < var_rank[i]; j++) {
#2403 if(var_rank[i] > 0) {
#2404     for (j = 0; j < var_rank[i]; j++) {
#2421     for (j = 0; j < var_rank[i]; j++) {
#2427        for (j = 0; j < var_rank[i]; j++) {
#2434            for (j = 0; j < var_rank[i]; j++) {
#2446                err = toMixedBase(jvar_rank[i], edgeindex);
#2449                for (d = 0; d < var_rank[i]; d++)
#2451                expect[j] = hash4(var_type[i], var_rank[i], indexNCT_SCHAR);
#2459            if (var_rank[i] == 0 && i%2)
#2533        assert(var_rank[i] <= MAX_RANK);
#2535 for (j = 0; j < var_rank[i]; j++) {
#2545 for (j = 0; j < var_rank[i]; j++) {
#2559 if(var_rank[i] > 0) {
#2560     for (j = 0; j < var_rank[i]; j++) {
#2577     for (j = 0; j < var_rank[i]; j++) {
#2583        for (j = 0; j < var_rank[i]; j++) {
#2590            for (j = 0; j < var_rank[i]; j++) {
#2602                err = toMixedBase(jvar_rank[i], edgeindex);
#2605                for (d = 0; d < var_rank[i]; d++)
#2607                expect[j] = hash4(var_type[i], var_rank[i], indexNCT_SHORT);
#2615            if (var_rank[i] == 0 && i%2)
#2689        assert(var_rank[i] <= MAX_RANK);
#2691 for (j = 0; j < var_rank[i]; j++) {
#2701 for (j = 0; j < var_rank[i]; j++) {
#2715 if(var_rank[i] > 0) {
#2716     for (j = 0; j < var_rank[i]; j++) {
#2733     for (j = 0; j < var_rank[i]; j++) {
#2739        for (j = 0; j < var_rank[i]; j++) {
#2746            for (j = 0; j < var_rank[i]; j++) {
#2758                err = toMixedBase(jvar_rank[i], edgeindex);
#2761                for (d = 0; d < var_rank[i]; d++)
#2763                expect[j] = hash4(var_type[i], var_rank[i], indexNCT_INT);
#2771            if (var_rank[i] == 0 && i%2)
#2845        assert(var_rank[i] <= MAX_RANK);
#2847 for (j = 0; j < var_rank[i]; j++) {
#2857 for (j = 0; j < var_rank[i]; j++) {
#2871 if(var_rank[i] > 0) {
#2872     for (j = 0; j < var_rank[i]; j++) {
#2889     for (j = 0; j < var_rank[i]; j++) {
#2895        for (j = 0; j < var_rank[i]; j++) {
#2902            for (j = 0; j < var_rank[i]; j++) {
#2914                err = toMixedBase(jvar_rank[i], edgeindex);
#2917                for (d = 0; d < var_rank[i]; d++)
#2919                expect[j] = hash4(var_type[i], var_rank[i], indexNCT_LONG);
#2927            if (var_rank[i] == 0 && i%2)
#3001        assert(var_rank[i] <= MAX_RANK);
#3003 for (j = 0; j < var_rank[i]; j++) {
#3013 for (j = 0; j < var_rank[i]; j++) {
#3027 if(var_rank[i] > 0) {
#3028     for (j = 0; j < var_rank[i]; j++) {
#3045     for (j = 0; j < var_rank[i]; j++) {
#3051        for (j = 0; j < var_rank[i]; j++) {
#3058            for (j = 0; j < var_rank[i]; j++) {
#3070                err = toMixedBase(jvar_rank[i], edgeindex);
#3073                for (d = 0; d < var_rank[i]; d++)
#3075                expect[j] = hash4(var_type[i], var_rank[i], indexNCT_FLOAT);
#3083            if (var_rank[i] == 0 && i%2)
#3157        assert(var_rank[i] <= MAX_RANK);
#3159 for (j = 0; j < var_rank[i]; j++) {
#3169 for (j = 0; j < var_rank[i]; j++) {
#3183 if(var_rank[i] > 0) {
#3184     for (j = 0; j < var_rank[i]; j++) {
#3201     for (j = 0; j < var_rank[i]; j++) {
#3207        for (j = 0; j < var_rank[i]; j++) {
#3214            for (j = 0; j < var_rank[i]; j++) {
#3226                err = toMixedBase(jvar_rank[i], edgeindex);
#3229                for (d = 0; d < var_rank[i]; d++)
#3231                expect[j] = hash4(var_type[i], var_rank[i], indexNCT_DOUBLE);
#3239            if (var_rank[i] == 0 && i%2)
#3313        assert(var_rank[i] <= MAX_RANK);
#3315 for (j = 0; j < var_rank[i]; j++) {
#3325 for (j = 0; j < var_rank[i]; j++) {
#3339 if(var_rank[i] > 0) {
#3340     for (j = 0; j < var_rank[i]; j++) {
#3357     for (j = 0; j < var_rank[i]; j++) {
#3363        for (j = 0; j < var_rank[i]; j++) {
#3370            for (j = 0; j < var_rank[i]; j++) {
#3382                err = toMixedBase(jvar_rank[i], edgeindex);
#3385                for (d = 0; d < var_rank[i]; d++)
#3387                expect[j] = hash4(var_type[i], var_rank[i], indexNCT_USHORT);
#3395            if (var_rank[i] == 0 && i%2)
#3469        assert(var_rank[i] <= MAX_RANK);
#3471 for (j = 0; j < var_rank[i]; j++) {
#3481 for (j = 0; j < var_rank[i]; j++) {
#3495 if(var_rank[i] > 0) {
#3496     for (j = 0; j < var_rank[i]; j++) {
#3513     for (j = 0; j < var_rank[i]; j++) {
#3519        for (j = 0; j < var_rank[i]; j++) {
#3526            for (j = 0; j < var_rank[i]; j++) {
#3538                err = toMixedBase(jvar_rank[i], edgeindex);
#3541                for (d = 0; d < var_rank[i]; d++)
#3543                expect[j] = hash4(var_type[i], var_rank[i], indexNCT_UINT);
#3551            if (var_rank[i] == 0 && i%2)
#3625        assert(var_rank[i] <= MAX_RANK);
#3627 for (j = 0; j < var_rank[i]; j++) {
#3637 for (j = 0; j < var_rank[i]; j++) {
#3651 if(var_rank[i] > 0) {
#3652     for (j = 0; j < var_rank[i]; j++) {
#3669     for (j = 0; j < var_rank[i]; j++) {
#3675        for (j = 0; j < var_rank[i]; j++) {
#3682            for (j = 0; j < var_rank[i]; j++) {
#3694                err = toMixedBase(jvar_rank[i], edgeindex);
#3697                for (d = 0; d < var_rank[i]; d++)
#3699                expect[j] = hash4(var_type[i], var_rank[i], indexNCT_LONGLONG);
#3707            if (var_rank[i] == 0 && i%2)
#3781        assert(var_rank[i] <= MAX_RANK);
#3783 for (j = 0; j < var_rank[i]; j++) {
#3793 for (j = 0; j < var_rank[i]; j++) {
#3807 if(var_rank[i] > 0) {
#3808     for (j = 0; j < var_rank[i]; j++) {
#3825     for (j = 0; j < var_rank[i]; j++) {
#3831        for (j = 0; j < var_rank[i]; j++) {
#3838            for (j = 0; j < var_rank[i]; j++) {
#3850                err = toMixedBase(jvar_rank[i], edgeindex);
#3853                for (d = 0; d < var_rank[i]; d++)
#3855                expect[j] = hash4(var_type[i], var_rank[i], indexNCT_ULONGLONG);
#3863            if (var_rank[i] == 0 && i%2)
#3946        assert(var_rank[i] <= MAX_RANK);
#3948        for (j = 0; j < var_rank[i]; j++) {
#3959        for (j = 0; j < var_rank[i]; j++) {
#3984        for (j = 0; j < var_rank[i]; j++) {
#3992            for (j = 0; j < var_rank[i]; j++) {
#4004                err = toMixedBase(mvar_rank[i], sstrideindex);
#4008                for (j = 0; j < var_rank[i]; j++) {
#4024     err = toMixedBase(jvar_rank[i], countindex2);
#4027     for (d = 0; d < var_rank[i]; d++)
#4029     expect[j] = hash4(var_type[i], var_rank[i], index2,
#4038                if (var_rank[i] == 0 && i%2 )
#4120        assert(var_rank[i] <= MAX_RANK);
#4122        for (j = 0; j < var_rank[i]; j++) {
#4133        for (j = 0; j < var_rank[i]; j++) {
#4158        for (j = 0; j < var_rank[i]; j++) {
#4166            for (j = 0; j < var_rank[i]; j++) {
#4178                err = toMixedBase(mvar_rank[i], sstrideindex);
#4182                for (j = 0; j < var_rank[i]; j++) {
#4198     err = toMixedBase(jvar_rank[i], countindex2);
#4201     for (d = 0; d < var_rank[i]; d++)
#4203     expect[j] = hash4(var_type[i], var_rank[i], index2,
#4212                if (var_rank[i] == 0 && i%2 )
#4294        assert(var_rank[i] <= MAX_RANK);
#4296        for (j = 0; j < var_rank[i]; j++) {
#4307        for (j = 0; j < var_rank[i]; j++) {
#4332        for (j = 0; j < var_rank[i]; j++) {
#4340            for (j = 0; j < var_rank[i]; j++) {
#4352                err = toMixedBase(mvar_rank[i], sstrideindex);
#4356                for (j = 0; j < var_rank[i]; j++) {
#4372     err = toMixedBase(jvar_rank[i], countindex2);
#4375     for (d = 0; d < var_rank[i]; d++)
#4377     expect[j] = hash4(var_type[i], var_rank[i], index2,
#4386                if (var_rank[i] == 0 && i%2 )
#4468        assert(var_rank[i] <= MAX_RANK);
#4470        for (j = 0; j < var_rank[i]; j++) {
#4481        for (j = 0; j < var_rank[i]; j++) {
#4506        for (j = 0; j < var_rank[i]; j++) {
#4514            for (j = 0; j < var_rank[i]; j++) {
#4526                err = toMixedBase(mvar_rank[i], sstrideindex);
#4530                for (j = 0; j < var_rank[i]; j++) {
#4546     err = toMixedBase(jvar_rank[i], countindex2);
#4549     for (d = 0; d < var_rank[i]; d++)
#4551     expect[j] = hash4(var_type[i], var_rank[i], index2,
#4560                if (var_rank[i] == 0 && i%2 )
#4642        assert(var_rank[i] <= MAX_RANK);
#4644        for (j = 0; j < var_rank[i]; j++) {
#4655        for (j = 0; j < var_rank[i]; j++) {
#4680        for (j = 0; j < var_rank[i]; j++) {
#4688            for (j = 0; j < var_rank[i]; j++) {
#4700                err = toMixedBase(mvar_rank[i], sstrideindex);
#4704                for (j = 0; j < var_rank[i]; j++) {
#4720     err = toMixedBase(jvar_rank[i], countindex2);
#4723     for (d = 0; d < var_rank[i]; d++)
#4725     expect[j] = hash4(var_type[i], var_rank[i], index2,
#4734                if (var_rank[i] == 0 && i%2 )
#4816        assert(var_rank[i] <= MAX_RANK);
#4818        for (j = 0; j < var_rank[i]; j++) {
#4829        for (j = 0; j < var_rank[i]; j++) {
#4854        for (j = 0; j < var_rank[i]; j++) {
#4862            for (j = 0; j < var_rank[i]; j++) {
#4874                err = toMixedBase(mvar_rank[i], sstrideindex);
#4878                for (j = 0; j < var_rank[i]; j++) {
#4894     err = toMixedBase(jvar_rank[i], countindex2);
#4897     for (d = 0; d < var_rank[i]; d++)
#4899     expect[j] = hash4(var_type[i], var_rank[i], index2,
#4908                if (var_rank[i] == 0 && i%2 )
#4990        assert(var_rank[i] <= MAX_RANK);
#4992        for (j = 0; j < var_rank[i]; j++) {
#5003        for (j = 0; j < var_rank[i]; j++) {
#5028        for (j = 0; j < var_rank[i]; j++) {
#5036            for (j = 0; j < var_rank[i]; j++) {
#5048                err = toMixedBase(mvar_rank[i], sstrideindex);
#5052                for (j = 0; j < var_rank[i]; j++) {
#5068     err = toMixedBase(jvar_rank[i], countindex2);
#5071     for (d = 0; d < var_rank[i]; d++)
#5073     expect[j] = hash4(var_type[i], var_rank[i], index2,
#5082                if (var_rank[i] == 0 && i%2 )
#5164        assert(var_rank[i] <= MAX_RANK);
#5166        for (j = 0; j < var_rank[i]; j++) {
#5177        for (j = 0; j < var_rank[i]; j++) {
#5202        for (j = 0; j < var_rank[i]; j++) {
#5210            for (j = 0; j < var_rank[i]; j++) {
#5222                err = toMixedBase(mvar_rank[i], sstrideindex);
#5226                for (j = 0; j < var_rank[i]; j++) {
#5242     err = toMixedBase(jvar_rank[i], countindex2);
#5245     for (d = 0; d < var_rank[i]; d++)
#5247     expect[j] = hash4(var_type[i], var_rank[i], index2,
#5256                if (var_rank[i] == 0 && i%2 )
#5338        assert(var_rank[i] <= MAX_RANK);
#5340        for (j = 0; j < var_rank[i]; j++) {
#5351        for (j = 0; j < var_rank[i]; j++) {
#5376        for (j = 0; j < var_rank[i]; j++) {
#5384            for (j = 0; j < var_rank[i]; j++) {
#5396                err = toMixedBase(mvar_rank[i], sstrideindex);
#5400                for (j = 0; j < var_rank[i]; j++) {
#5416     err = toMixedBase(jvar_rank[i], countindex2);
#5419     for (d = 0; d < var_rank[i]; d++)
#5421     expect[j] = hash4(var_type[i], var_rank[i], index2,
#5430                if (var_rank[i] == 0 && i%2 )
#5512        assert(var_rank[i] <= MAX_RANK);
#5514        for (j = 0; j < var_rank[i]; j++) {
#5525        for (j = 0; j < var_rank[i]; j++) {
#5550        for (j = 0; j < var_rank[i]; j++) {
#5558            for (j = 0; j < var_rank[i]; j++) {
#5570                err = toMixedBase(mvar_rank[i], sstrideindex);
#5574                for (j = 0; j < var_rank[i]; j++) {
#5590     err = toMixedBase(jvar_rank[i], countindex2);
#5593     for (d = 0; d < var_rank[i]; d++)
#5595     expect[j] = hash4(var_type[i], var_rank[i], index2,
#5604                if (var_rank[i] == 0 && i%2 )
#5686        assert(var_rank[i] <= MAX_RANK);
#5688        for (j = 0; j < var_rank[i]; j++) {
#5699        for (j = 0; j < var_rank[i]; j++) {
#5724        for (j = 0; j < var_rank[i]; j++) {
#5732            for (j = 0; j < var_rank[i]; j++) {
#5744                err = toMixedBase(mvar_rank[i], sstrideindex);
#5748                for (j = 0; j < var_rank[i]; j++) {
#5764     err = toMixedBase(jvar_rank[i], countindex2);
#5767     for (d = 0; d < var_rank[i]; d++)
#5769     expect[j] = hash4(var_type[i], var_rank[i], index2,
#5778                if (var_rank[i] == 0 && i%2 )
#5860        assert(var_rank[i] <= MAX_RANK);
#5862        for (j = 0; j < var_rank[i]; j++) {
#5873        for (j = 0; j < var_rank[i]; j++) {
#5898        for (j = 0; j < var_rank[i]; j++) {
#5906            for (j = 0; j < var_rank[i]; j++) {
#5918                err = toMixedBase(mvar_rank[i], sstrideindex);
#5922                for (j = 0; j < var_rank[i]; j++) {
#5938     err = toMixedBase(jvar_rank[i], countindex2);
#5941     for (d = 0; d < var_rank[i]; d++)
#5943     expect[j] = hash4(var_type[i], var_rank[i], index2,
#5952                if (var_rank[i] == 0 && i%2 )
#6038        assert(var_rank[i] <= MAX_RANK);
#6040        for (j = 0; j < var_rank[i]; j++) {
#6052        for (j = 0; j < var_rank[i]; j++) {
#6077        for (j = 0; j < var_rank[i]; j++) {
#6085            for (j = 0; j < var_rank[i]; j++) {
#6097                err = toMixedBase(mvar_rank[i], sstrideindex);
#6101                for (j = 0; j < var_rank[i]; j++) {
#6115 if (var_rank[i] > 0) {
#6116     j = var_rank[i] - 1;
#6123                    err = toMixedBase(jvar_rank[i], countindex2);
#6126                    for (d = 0; d < var_rank[i]; d++)
#6128                    expect[j] = hash4(var_type[i], var_rank[i], index2,
#6137                if (var_rank[i] == 0 && i%2 )
#6220        assert(var_rank[i] <= MAX_RANK);
#6222        for (j = 0; j < var_rank[i]; j++) {
#6234        for (j = 0; j < var_rank[i]; j++) {
#6259        for (j = 0; j < var_rank[i]; j++) {
#6267            for (j = 0; j < var_rank[i]; j++) {
#6279                err = toMixedBase(mvar_rank[i], sstrideindex);
#6283                for (j = 0; j < var_rank[i]; j++) {
#6297 if (var_rank[i] > 0) {
#6298     j = var_rank[i] - 1;
#6305                    err = toMixedBase(jvar_rank[i], countindex2);
#6308                    for (d = 0; d < var_rank[i]; d++)
#6310                    expect[j] = hash4(var_type[i], var_rank[i], index2,
#6319                if (var_rank[i] == 0 && i%2 )
#6402        assert(var_rank[i] <= MAX_RANK);
#6404        for (j = 0; j < var_rank[i]; j++) {
#6416        for (j = 0; j < var_rank[i]; j++) {
#6441        for (j = 0; j < var_rank[i]; j++) {
#6449            for (j = 0; j < var_rank[i]; j++) {
#6461                err = toMixedBase(mvar_rank[i], sstrideindex);
#6465                for (j = 0; j < var_rank[i]; j++) {
#6479 if (var_rank[i] > 0) {
#6480     j = var_rank[i] - 1;
#6487                    err = toMixedBase(jvar_rank[i], countindex2);
#6490                    for (d = 0; d < var_rank[i]; d++)
#6492                    expect[j] = hash4(var_type[i], var_rank[i], index2,
#6501                if (var_rank[i] == 0 && i%2 )
#6584        assert(var_rank[i] <= MAX_RANK);
#6586        for (j = 0; j < var_rank[i]; j++) {
#6598        for (j = 0; j < var_rank[i]; j++) {
#6623        for (j = 0; j < var_rank[i]; j++) {
#6631            for (j = 0; j < var_rank[i]; j++) {
#6643                err = toMixedBase(mvar_rank[i], sstrideindex);
#6647                for (j = 0; j < var_rank[i]; j++) {
#6661 if (var_rank[i] > 0) {
#6662     j = var_rank[i] - 1;
#6669                    err = toMixedBase(jvar_rank[i], countindex2);
#6672                    for (d = 0; d < var_rank[i]; d++)
#6674                    expect[j] = hash4(var_type[i], var_rank[i], index2,
#6683                if (var_rank[i] == 0 && i%2 )
#6766        assert(var_rank[i] <= MAX_RANK);
#6768        for (j = 0; j < var_rank[i]; j++) {
#6780        for (j = 0; j < var_rank[i]; j++) {
#6805        for (j = 0; j < var_rank[i]; j++) {
#6813            for (j = 0; j < var_rank[i]; j++) {
#6825                err = toMixedBase(mvar_rank[i], sstrideindex);
#6829                for (j = 0; j < var_rank[i]; j++) {
#6843 if (var_rank[i] > 0) {
#6844     j = var_rank[i] - 1;
#6851                    err = toMixedBase(jvar_rank[i], countindex2);
#6854                    for (d = 0; d < var_rank[i]; d++)
#6856                    expect[j] = hash4(var_type[i], var_rank[i], index2,
#6865                if (var_rank[i] == 0 && i%2 )
#6948        assert(var_rank[i] <= MAX_RANK);
#6950        for (j = 0; j < var_rank[i]; j++) {
#6962        for (j = 0; j < var_rank[i]; j++) {
#6987        for (j = 0; j < var_rank[i]; j++) {
#6995            for (j = 0; j < var_rank[i]; j++) {
#7007                err = toMixedBase(mvar_rank[i], sstrideindex);
#7011                for (j = 0; j < var_rank[i]; j++) {
#7025 if (var_rank[i] > 0) {
#7026     j = var_rank[i] - 1;
#7033                    err = toMixedBase(jvar_rank[i], countindex2);
#7036                    for (d = 0; d < var_rank[i]; d++)
#7038                    expect[j] = hash4(var_type[i], var_rank[i], index2,
#7047                if (var_rank[i] == 0 && i%2 )
#7130        assert(var_rank[i] <= MAX_RANK);
#7132        for (j = 0; j < var_rank[i]; j++) {
#7144        for (j = 0; j < var_rank[i]; j++) {
#7169        for (j = 0; j < var_rank[i]; j++) {
#7177            for (j = 0; j < var_rank[i]; j++) {
#7189                err = toMixedBase(mvar_rank[i], sstrideindex);
#7193                for (j = 0; j < var_rank[i]; j++) {
#7207 if (var_rank[i] > 0) {
#7208     j = var_rank[i] - 1;
#7215                    err = toMixedBase(jvar_rank[i], countindex2);
#7218                    for (d = 0; d < var_rank[i]; d++)
#7220                    expect[j] = hash4(var_type[i], var_rank[i], index2,
#7229                if (var_rank[i] == 0 && i%2 )
#7312        assert(var_rank[i] <= MAX_RANK);
#7314        for (j = 0; j < var_rank[i]; j++) {
#7326        for (j = 0; j < var_rank[i]; j++) {
#7351        for (j = 0; j < var_rank[i]; j++) {
#7359            for (j = 0; j < var_rank[i]; j++) {
#7371                err = toMixedBase(mvar_rank[i], sstrideindex);
#7375                for (j = 0; j < var_rank[i]; j++) {
#7389 if (var_rank[i] > 0) {
#7390     j = var_rank[i] - 1;
#7397                    err = toMixedBase(jvar_rank[i], countindex2);
#7400                    for (d = 0; d < var_rank[i]; d++)
#7402                    expect[j] = hash4(var_type[i], var_rank[i], index2,
#7411                if (var_rank[i] == 0 && i%2 )
#7494        assert(var_rank[i] <= MAX_RANK);
#7496        for (j = 0; j < var_rank[i]; j++) {
#7508        for (j = 0; j < var_rank[i]; j++) {
#7533        for (j = 0; j < var_rank[i]; j++) {
#7541            for (j = 0; j < var_rank[i]; j++) {
#7553                err = toMixedBase(mvar_rank[i], sstrideindex);
#7557                for (j = 0; j < var_rank[i]; j++) {
#7571 if (var_rank[i] > 0) {
#7572     j = var_rank[i] - 1;
#7579                    err = toMixedBase(jvar_rank[i], countindex2);
#7582                    for (d = 0; d < var_rank[i]; d++)
#7584                    expect[j] = hash4(var_type[i], var_rank[i], index2,
#7593                if (var_rank[i] == 0 && i%2 )
#7676        assert(var_rank[i] <= MAX_RANK);
#7678        for (j = 0; j < var_rank[i]; j++) {
#7690        for (j = 0; j < var_rank[i]; j++) {
#7715        for (j = 0; j < var_rank[i]; j++) {
#7723            for (j = 0; j < var_rank[i]; j++) {
#7735                err = toMixedBase(mvar_rank[i], sstrideindex);
#7739                for (j = 0; j < var_rank[i]; j++) {
#7753 if (var_rank[i] > 0) {
#7754     j = var_rank[i] - 1;
#7761                    err = toMixedBase(jvar_rank[i], countindex2);
#7764                    for (d = 0; d < var_rank[i]; d++)
#7766                    expect[j] = hash4(var_type[i], var_rank[i], index2,
#7775                if (var_rank[i] == 0 && i%2 )
#7858        assert(var_rank[i] <= MAX_RANK);
#7860        for (j = 0; j < var_rank[i]; j++) {
#7872        for (j = 0; j < var_rank[i]; j++) {
#7897        for (j = 0; j < var_rank[i]; j++) {
#7905            for (j = 0; j < var_rank[i]; j++) {
#7917                err = toMixedBase(mvar_rank[i], sstrideindex);
#7921                for (j = 0; j < var_rank[i]; j++) {
#7935 if (var_rank[i] > 0) {
#7936     j = var_rank[i] - 1;
#7943                    err = toMixedBase(jvar_rank[i], countindex2);
#7946                    for (d = 0; d < var_rank[i]; d++)
#7948                    expect[j] = hash4(var_type[i], var_rank[i], index2,
#7957                if (var_rank[i] == 0 && i%2 )
#8040        assert(var_rank[i] <= MAX_RANK);
#8042        for (j = 0; j < var_rank[i]; j++) {
#8054        for (j = 0; j < var_rank[i]; j++) {
#8079        for (j = 0; j < var_rank[i]; j++) {
#8087            for (j = 0; j < var_rank[i]; j++) {
#8099                err = toMixedBase(mvar_rank[i], sstrideindex);
#8103                for (j = 0; j < var_rank[i]; j++) {
#8117 if (var_rank[i] > 0) {
#8118     j = var_rank[i] - 1;
#8125                    err = toMixedBase(jvar_rank[i], countindex2);
#8128                    for (d = 0; d < var_rank[i]; d++)
#8130                    expect[j] = hash4(var_type[i], var_rank[i], index2,
#8139                if (var_rank[i] == 0 && i%2 )
test_put.c#260     IF (ndims != var_rank[i])
#270 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#273 expect = hash4var_type[i], var_rank[i], indexNCT_TEXT);
#287     for (d = 0; d < var_rank[i]; d++)
#344     IF (ndims != var_rank[i])
#354 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#357 expect = hash4var_type[i], var_rank[i], indexNCT_UCHAR);
#371     for (d = 0; d < var_rank[i]; d++)
#428     IF (ndims != var_rank[i])
#438 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#441 expect = hash4var_type[i], var_rank[i], indexNCT_SCHAR);
#455     for (d = 0; d < var_rank[i]; d++)
#512     IF (ndims != var_rank[i])
#522 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#525 expect = hash4var_type[i], var_rank[i], indexNCT_SHORT);
#539     for (d = 0; d < var_rank[i]; d++)
#596     IF (ndims != var_rank[i])
#606 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#609 expect = hash4var_type[i], var_rank[i], indexNCT_INT);
#623     for (d = 0; d < var_rank[i]; d++)
#680     IF (ndims != var_rank[i])
#690 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#693 expect = hash4var_type[i], var_rank[i], indexNCT_LONG);
#707     for (d = 0; d < var_rank[i]; d++)
#764     IF (ndims != var_rank[i])
#774 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#777 expect = hash4var_type[i], var_rank[i], indexNCT_FLOAT);
#791     for (d = 0; d < var_rank[i]; d++)
#848     IF (ndims != var_rank[i])
#858 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#861 expect = hash4var_type[i], var_rank[i], indexNCT_DOUBLE);
#875     for (d = 0; d < var_rank[i]; d++)
#932     IF (ndims != var_rank[i])
#942 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#945 expect = hash4var_type[i], var_rank[i], indexNCT_USHORT);
#959     for (d = 0; d < var_rank[i]; d++)
#1016     IF (ndims != var_rank[i])
#1026 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1029 expect = hash4var_type[i], var_rank[i], indexNCT_UINT);
#1043     for (d = 0; d < var_rank[i]; d++)
#1100     IF (ndims != var_rank[i])
#1110 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1113 expect = hash4var_type[i], var_rank[i], indexNCT_LONGLONG);
#1127     for (d = 0; d < var_rank[i]; d++)
#1184     IF (ndims != var_rank[i])
#1194 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1197 expect = hash4var_type[i], var_rank[i], indexNCT_ULONGLONG);
#1211     for (d = 0; d < var_rank[i]; d++)
#2175        for (j = 0; j < var_rank[i]; j++)
#2183        for (j = 0; j < var_rank[i]; j++) {
#2193            err = toMixedBase(jvar_rank[i], var_shape[i], index);
#2196            value = hash_textvar_type[i], var_rank[i], indexNCT_TEXT);
#2197     if (var_rank[i] == 0 && i%2 == 0)
#2269        for (j = 0; j < var_rank[i]; j++)
#2277        for (j = 0; j < var_rank[i]; j++) {
#2287            err = toMixedBase(jvar_rank[i], var_shape[i], index);
#2290            value = hash_ucharvar_type[i], var_rank[i], indexNCT_UCHAR);
#2291     if (var_rank[i] == 0 && i%2 == 0)
#2363        for (j = 0; j < var_rank[i]; j++)
#2371        for (j = 0; j < var_rank[i]; j++) {
#2381            err = toMixedBase(jvar_rank[i], var_shape[i], index);
#2384            value = hash_scharvar_type[i], var_rank[i], indexNCT_SCHAR);
#2385     if (var_rank[i] == 0 && i%2 == 0)
#2457        for (j = 0; j < var_rank[i]; j++)
#2465        for (j = 0; j < var_rank[i]; j++) {
#2475            err = toMixedBase(jvar_rank[i], var_shape[i], index);
#2478            value = hash_shortvar_type[i], var_rank[i], indexNCT_SHORT);
#2479     if (var_rank[i] == 0 && i%2 == 0)
#2551        for (j = 0; j < var_rank[i]; j++)
#2559        for (j = 0; j < var_rank[i]; j++) {
#2569            err = toMixedBase(jvar_rank[i], var_shape[i], index);
#2572            value = hash_intvar_type[i], var_rank[i], indexNCT_INT);
#2573     if (var_rank[i] == 0 && i%2 == 0)
#2645        for (j = 0; j < var_rank[i]; j++)
#2653        for (j = 0; j < var_rank[i]; j++) {
#2663            err = toMixedBase(jvar_rank[i], var_shape[i], index);
#2666            value = hash_longvar_type[i], var_rank[i], indexNCT_LONG);
#2667     if (var_rank[i] == 0 && i%2 == 0)
#2739        for (j = 0; j < var_rank[i]; j++)
#2747        for (j = 0; j < var_rank[i]; j++) {
#2757            err = toMixedBase(jvar_rank[i], var_shape[i], index);
#2760            value = hash_floatvar_type[i], var_rank[i], indexNCT_FLOAT);
#2761     if (var_rank[i] == 0 && i%2 == 0)
#2833        for (j = 0; j < var_rank[i]; j++)
#2841        for (j = 0; j < var_rank[i]; j++) {
#2851            err = toMixedBase(jvar_rank[i], var_shape[i], index);
#2854            value = hash_doublevar_type[i], var_rank[i], indexNCT_DOUBLE);
#2855     if (var_rank[i] == 0 && i%2 == 0)
#2927        for (j = 0; j < var_rank[i]; j++)
#2935        for (j = 0; j < var_rank[i]; j++) {
#2945            err = toMixedBase(jvar_rank[i], var_shape[i], index);
#2948            value = hash_ushortvar_type[i], var_rank[i], indexNCT_USHORT);
#2949     if (var_rank[i] == 0 && i%2 == 0)
#3021        for (j = 0; j < var_rank[i]; j++)
#3029        for (j = 0; j < var_rank[i]; j++) {
#3039            err = toMixedBase(jvar_rank[i], var_shape[i], index);
#3042            value = hash_uintvar_type[i], var_rank[i], indexNCT_UINT);
#3043     if (var_rank[i] == 0 && i%2 == 0)
#3115        for (j = 0; j < var_rank[i]; j++)
#3123        for (j = 0; j < var_rank[i]; j++) {
#3133            err = toMixedBase(jvar_rank[i], var_shape[i], index);
#3136            value = hash_longlongvar_type[i], var_rank[i], indexNCT_LONGLONG);
#3137     if (var_rank[i] == 0 && i%2 == 0)
#3209        for (j = 0; j < var_rank[i]; j++)
#3217        for (j = 0; j < var_rank[i]; j++) {
#3227            err = toMixedBase(jvar_rank[i], var_shape[i], index);
#3230            value = hash_ulonglongvar_type[i], var_rank[i], indexNCT_ULONGLONG);
#3231     if (var_rank[i] == 0 && i%2 == 0)
#3309        assert(var_rank[i] <= MAX_RANK);
#3319 for (j = 0; j < var_rank[i]; j++) {
#3323     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#3326     value[j]= hash_text(var_type[i], var_rank[i], indexNCT_TEXT);
#3361     assert(var_rank[i] <= MAX_RANK);
#3367     for (j = 0; j < var_rank[i]; j++) {
#3371 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#3374 value[j]= hash_text(var_type[i], var_rank[i], indexNCT_TEXT);
#3446        assert(var_rank[i] <= MAX_RANK);
#3456 for (j = 0; j < var_rank[i]; j++) {
#3460     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#3463     value[j]= hash_uchar(var_type[i], var_rank[i], indexNCT_UCHAR);
#3498     assert(var_rank[i] <= MAX_RANK);
#3504     for (j = 0; j < var_rank[i]; j++) {
#3508 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#3511 value[j]= hash_uchar(var_type[i], var_rank[i], indexNCT_UCHAR);
#3583        assert(var_rank[i] <= MAX_RANK);
#3593 for (j = 0; j < var_rank[i]; j++) {
#3597     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#3600     value[j]= hash_schar(var_type[i], var_rank[i], indexNCT_SCHAR);
#3635     assert(var_rank[i] <= MAX_RANK);
#3641     for (j = 0; j < var_rank[i]; j++) {
#3645 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#3648 value[j]= hash_schar(var_type[i], var_rank[i], indexNCT_SCHAR);
#3720        assert(var_rank[i] <= MAX_RANK);
#3730 for (j = 0; j < var_rank[i]; j++) {
#3734     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#3737     value[j]= hash_short(var_type[i], var_rank[i], indexNCT_SHORT);
#3772     assert(var_rank[i] <= MAX_RANK);
#3778     for (j = 0; j < var_rank[i]; j++) {
#3782 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#3785 value[j]= hash_short(var_type[i], var_rank[i], indexNCT_SHORT);
#3857        assert(var_rank[i] <= MAX_RANK);
#3867 for (j = 0; j < var_rank[i]; j++) {
#3871     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#3874     value[j]= hash_int(var_type[i], var_rank[i], indexNCT_INT);
#3909     assert(var_rank[i] <= MAX_RANK);
#3915     for (j = 0; j < var_rank[i]; j++) {
#3919 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#3922 value[j]= hash_int(var_type[i], var_rank[i], indexNCT_INT);
#3994        assert(var_rank[i] <= MAX_RANK);
#4004 for (j = 0; j < var_rank[i]; j++) {
#4008     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#4011     value[j]= hash_long(var_type[i], var_rank[i], indexNCT_LONG);
#4046     assert(var_rank[i] <= MAX_RANK);
#4052     for (j = 0; j < var_rank[i]; j++) {
#4056 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#4059 value[j]= hash_long(var_type[i], var_rank[i], indexNCT_LONG);
#4131        assert(var_rank[i] <= MAX_RANK);
#4141 for (j = 0; j < var_rank[i]; j++) {
#4145     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#4148     value[j]= hash_float(var_type[i], var_rank[i], indexNCT_FLOAT);
#4183     assert(var_rank[i] <= MAX_RANK);
#4189     for (j = 0; j < var_rank[i]; j++) {
#4193 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#4196 value[j]= hash_float(var_type[i], var_rank[i], indexNCT_FLOAT);
#4268        assert(var_rank[i] <= MAX_RANK);
#4278 for (j = 0; j < var_rank[i]; j++) {
#4282     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#4285     value[j]= hash_double(var_type[i], var_rank[i], indexNCT_DOUBLE);
#4320     assert(var_rank[i] <= MAX_RANK);
#4326     for (j = 0; j < var_rank[i]; j++) {
#4330 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#4333 value[j]= hash_double(var_type[i], var_rank[i], indexNCT_DOUBLE);
#4405        assert(var_rank[i] <= MAX_RANK);
#4415 for (j = 0; j < var_rank[i]; j++) {
#4419     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#4422     value[j]= hash_ushort(var_type[i], var_rank[i], indexNCT_USHORT);
#4457     assert(var_rank[i] <= MAX_RANK);
#4463     for (j = 0; j < var_rank[i]; j++) {
#4467 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#4470 value[j]= hash_ushort(var_type[i], var_rank[i], indexNCT_USHORT);
#4542        assert(var_rank[i] <= MAX_RANK);
#4552 for (j = 0; j < var_rank[i]; j++) {
#4556     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#4559     value[j]= hash_uint(var_type[i], var_rank[i], indexNCT_UINT);
#4594     assert(var_rank[i] <= MAX_RANK);
#4600     for (j = 0; j < var_rank[i]; j++) {
#4604 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#4607 value[j]= hash_uint(var_type[i], var_rank[i], indexNCT_UINT);
#4679        assert(var_rank[i] <= MAX_RANK);
#4689 for (j = 0; j < var_rank[i]; j++) {
#4693     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#4696     value[j]= hash_longlong(var_type[i], var_rank[i], indexNCT_LONGLONG);
#4731     assert(var_rank[i] <= MAX_RANK);
#4737     for (j = 0; j < var_rank[i]; j++) {
#4741 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#4744 value[j]= hash_longlong(var_type[i], var_rank[i], indexNCT_LONGLONG);
#4816        assert(var_rank[i] <= MAX_RANK);
#4826 for (j = 0; j < var_rank[i]; j++) {
#4830     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#4833     value[j]= hash_ulonglong(var_type[i], var_rank[i], indexNCT_ULONGLONG);
#4868     assert(var_rank[i] <= MAX_RANK);
#4874     for (j = 0; j < var_rank[i]; j++) {
#4878 err = toMixedBase(jvar_rank[i], var_shape[i], index);
#4881 value[j]= hash_ulonglong(var_type[i], var_rank[i], indexNCT_ULONGLONG);
#4962        assert(var_rank[i] <= MAX_RANK);
#4964        for (j = 0; j < var_rank[i]; j++) {
#4974        for (j = 0; j < var_rank[i]; j++) {
#5002        for (j = 0; j < var_rank[i]; j++) {
#5009 for (j = 0; j < var_rank[i]; j++) {
#5016     for (j = 0; j < var_rank[i]; j++) {
#5027 err = toMixedBase(jvar_rank[i], edgeindex);
#5030 for (d = 0; d < var_rank[i]; d++)
#5032 value[j]= hash_text(var_type[i], var_rank[i], indexNCT_TEXT);
#5036     if (var_rank[i] == 0 && i%2 == 0)
#5113        assert(var_rank[i] <= MAX_RANK);
#5115        for (j = 0; j < var_rank[i]; j++) {
#5125        for (j = 0; j < var_rank[i]; j++) {
#5153        for (j = 0; j < var_rank[i]; j++) {
#5160 for (j = 0; j < var_rank[i]; j++) {
#5167     for (j = 0; j < var_rank[i]; j++) {
#5178 err = toMixedBase(jvar_rank[i], edgeindex);
#5181 for (d = 0; d < var_rank[i]; d++)
#5183 value[j]= hash_uchar(var_type[i], var_rank[i], indexNCT_UCHAR);
#5187     if (var_rank[i] == 0 && i%2 == 0)
#5264        assert(var_rank[i] <= MAX_RANK);
#5266        for (j = 0; j < var_rank[i]; j++) {
#5276        for (j = 0; j < var_rank[i]; j++) {
#5304        for (j = 0; j < var_rank[i]; j++) {
#5311 for (j = 0; j < var_rank[i]; j++) {
#5318     for (j = 0; j < var_rank[i]; j++) {
#5329 err = toMixedBase(jvar_rank[i], edgeindex);
#5332 for (d = 0; d < var_rank[i]; d++)
#5334 value[j]= hash_schar(var_type[i], var_rank[i], indexNCT_SCHAR);
#5338     if (var_rank[i] == 0 && i%2 == 0)
#5415        assert(var_rank[i] <= MAX_RANK);
#5417        for (j = 0; j < var_rank[i]; j++) {
#5427        for (j = 0; j < var_rank[i]; j++) {
#5455        for (j = 0; j < var_rank[i]; j++) {
#5462 for (j = 0; j < var_rank[i]; j++) {
#5469     for (j = 0; j < var_rank[i]; j++) {
#5480 err = toMixedBase(jvar_rank[i], edgeindex);
#5483 for (d = 0; d < var_rank[i]; d++)
#5485 value[j]= hash_short(var_type[i], var_rank[i], indexNCT_SHORT);
#5489     if (var_rank[i] == 0 && i%2 == 0)
#5566        assert(var_rank[i] <= MAX_RANK);
#5568        for (j = 0; j < var_rank[i]; j++) {
#5578        for (j = 0; j < var_rank[i]; j++) {
#5606        for (j = 0; j < var_rank[i]; j++) {
#5613 for (j = 0; j < var_rank[i]; j++) {
#5620     for (j = 0; j < var_rank[i]; j++) {
#5631 err = toMixedBase(jvar_rank[i], edgeindex);
#5634 for (d = 0; d < var_rank[i]; d++)
#5636 value[j]= hash_int(var_type[i], var_rank[i], indexNCT_INT);
#5640     if (var_rank[i] == 0 && i%2 == 0)
#5717        assert(var_rank[i] <= MAX_RANK);
#5719        for (j = 0; j < var_rank[i]; j++) {
#5729        for (j = 0; j < var_rank[i]; j++) {
#5757        for (j = 0; j < var_rank[i]; j++) {
#5764 for (j = 0; j < var_rank[i]; j++) {
#5771     for (j = 0; j < var_rank[i]; j++) {
#5782 err = toMixedBase(jvar_rank[i], edgeindex);
#5785 for (d = 0; d < var_rank[i]; d++)
#5787 value[j]= hash_long(var_type[i], var_rank[i], indexNCT_LONG);
#5791     if (var_rank[i] == 0 && i%2 == 0)
#5868        assert(var_rank[i] <= MAX_RANK);
#5870        for (j = 0; j < var_rank[i]; j++) {
#5880        for (j = 0; j < var_rank[i]; j++) {
#5908        for (j = 0; j < var_rank[i]; j++) {
#5915 for (j = 0; j < var_rank[i]; j++) {
#5922     for (j = 0; j < var_rank[i]; j++) {
#5933 err = toMixedBase(jvar_rank[i], edgeindex);
#5936 for (d = 0; d < var_rank[i]; d++)
#5938 value[j]= hash_float(var_type[i], var_rank[i], indexNCT_FLOAT);
#5942     if (var_rank[i] == 0 && i%2 == 0)
#6019        assert(var_rank[i] <= MAX_RANK);
#6021        for (j = 0; j < var_rank[i]; j++) {
#6031        for (j = 0; j < var_rank[i]; j++) {
#6059        for (j = 0; j < var_rank[i]; j++) {
#6066 for (j = 0; j < var_rank[i]; j++) {
#6073     for (j = 0; j < var_rank[i]; j++) {
#6084 err = toMixedBase(jvar_rank[i], edgeindex);
#6087 for (d = 0; d < var_rank[i]; d++)
#6089 value[j]= hash_double(var_type[i], var_rank[i], indexNCT_DOUBLE);
#6093     if (var_rank[i] == 0 && i%2 == 0)
#6170        assert(var_rank[i] <= MAX_RANK);
#6172        for (j = 0; j < var_rank[i]; j++) {
#6182        for (j = 0; j < var_rank[i]; j++) {
#6210        for (j = 0; j < var_rank[i]; j++) {
#6217 for (j = 0; j < var_rank[i]; j++) {
#6224     for (j = 0; j < var_rank[i]; j++) {
#6235 err = toMixedBase(jvar_rank[i], edgeindex);
#6238 for (d = 0; d < var_rank[i]; d++)
#6240 value[j]= hash_ushort(var_type[i], var_rank[i], indexNCT_USHORT);
#6244     if (var_rank[i] == 0 && i%2 == 0)
#6321        assert(var_rank[i] <= MAX_RANK);
#6323        for (j = 0; j < var_rank[i]; j++) {
#6333        for (j = 0; j < var_rank[i]; j++) {
#6361        for (j = 0; j < var_rank[i]; j++) {
#6368 for (j = 0; j < var_rank[i]; j++) {
#6375     for (j = 0; j < var_rank[i]; j++) {
#6386 err = toMixedBase(jvar_rank[i], edgeindex);
#6389 for (d = 0; d < var_rank[i]; d++)
#6391 value[j]= hash_uint(var_type[i], var_rank[i], indexNCT_UINT);
#6395     if (var_rank[i] == 0 && i%2 == 0)
#6472        assert(var_rank[i] <= MAX_RANK);
#6474        for (j = 0; j < var_rank[i]; j++) {
#6484        for (j = 0; j < var_rank[i]; j++) {
#6512        for (j = 0; j < var_rank[i]; j++) {
#6519 for (j = 0; j < var_rank[i]; j++) {
#6526     for (j = 0; j < var_rank[i]; j++) {
#6537 err = toMixedBase(jvar_rank[i], edgeindex);
#6540 for (d = 0; d < var_rank[i]; d++)
#6542 value[j]= hash_longlong(var_type[i], var_rank[i], indexNCT_LONGLONG);
#6546     if (var_rank[i] == 0 && i%2 == 0)
#6623        assert(var_rank[i] <= MAX_RANK);
#6625        for (j = 0; j < var_rank[i]; j++) {
#6635        for (j = 0; j < var_rank[i]; j++) {
#6663        for (j = 0; j < var_rank[i]; j++) {
#6670 for (j = 0; j < var_rank[i]; j++) {
#6677     for (j = 0; j < var_rank[i]; j++) {
#6688 err = toMixedBase(jvar_rank[i], edgeindex);
#6691 for (d = 0; d < var_rank[i]; d++)
#6693 value[j]= hash_ulonglong(var_type[i], var_rank[i], indexNCT_ULONGLONG);
#6697     if (var_rank[i] == 0 && i%2 == 0)
#6782 assert(var_rank[i] <= MAX_RANK);
#6784 for (j = 0; j < var_rank[i]; j++) {
#6795 for (j = 0; j < var_rank[i]; j++) {
#6822 for (j = 0; j < var_rank[i]; j++) {
#6830     for (j = 0; j < var_rank[i]; j++) {
#6842 err = toMixedBase(mvar_rank[i], sstrideindex);
#6846 for (j = 0; j < var_rank[i]; j++) {
#6861     err = toMixedBase(jvar_rank[i], countindex2);
#6864     for (d = 0; d < var_rank[i]; d++)
#6866     value[j] = hash_text(var_type[i], var_rank[i], index2,
#6871 if (var_rank[i] == 0 && i%2 == 0)
#6954 assert(var_rank[i] <= MAX_RANK);
#6956 for (j = 0; j < var_rank[i]; j++) {
#6967 for (j = 0; j < var_rank[i]; j++) {
#6994 for (j = 0; j < var_rank[i]; j++) {
#7002     for (j = 0; j < var_rank[i]; j++) {
#7014 err = toMixedBase(mvar_rank[i], sstrideindex);
#7018 for (j = 0; j < var_rank[i]; j++) {
#7033     err = toMixedBase(jvar_rank[i], countindex2);
#7036     for (d = 0; d < var_rank[i]; d++)
#7038     value[j] = hash_uchar(var_type[i], var_rank[i], index2,
#7043 if (var_rank[i] == 0 && i%2 == 0)
#7126 assert(var_rank[i] <= MAX_RANK);
#7128 for (j = 0; j < var_rank[i]; j++) {
#7139 for (j = 0; j < var_rank[i]; j++) {
#7166 for (j = 0; j < var_rank[i]; j++) {
#7174     for (j = 0; j < var_rank[i]; j++) {
#7186 err = toMixedBase(mvar_rank[i], sstrideindex);
#7190 for (j = 0; j < var_rank[i]; j++) {
#7205     err = toMixedBase(jvar_rank[i], countindex2);
#7208     for (d = 0; d < var_rank[i]; d++)
#7210     value[j] = hash_schar(var_type[i], var_rank[i], index2,
#7215 if (var_rank[i] == 0 && i%2 == 0)
#7298 assert(var_rank[i] <= MAX_RANK);
#7300 for (j = 0; j < var_rank[i]; j++) {
#7311 for (j = 0; j < var_rank[i]; j++) {
#7338 for (j = 0; j < var_rank[i]; j++) {
#7346     for (j = 0; j < var_rank[i]; j++) {
#7358 err = toMixedBase(mvar_rank[i], sstrideindex);
#7362 for (j = 0; j < var_rank[i]; j++) {
#7377     err = toMixedBase(jvar_rank[i], countindex2);
#7380     for (d = 0; d < var_rank[i]; d++)
#7382     value[j] = hash_short(var_type[i], var_rank[i], index2,
#7387 if (var_rank[i] == 0 && i%2 == 0)
#7470 assert(var_rank[i] <= MAX_RANK);
#7472 for (j = 0; j < var_rank[i]; j++) {
#7483 for (j = 0; j < var_rank[i]; j++) {
#7510 for (j = 0; j < var_rank[i]; j++) {
#7518     for (j = 0; j < var_rank[i]; j++) {
#7530 err = toMixedBase(mvar_rank[i], sstrideindex);
#7534 for (j = 0; j < var_rank[i]; j++) {
#7549     err = toMixedBase(jvar_rank[i], countindex2);
#7552     for (d = 0; d < var_rank[i]; d++)
#7554     value[j] = hash_int(var_type[i], var_rank[i], index2,
#7559 if (var_rank[i] == 0 && i%2 == 0)
#7642 assert(var_rank[i] <= MAX_RANK);
#7644 for (j = 0; j < var_rank[i]; j++) {
#7655 for (j = 0; j < var_rank[i]; j++) {
#7682 for (j = 0; j < var_rank[i]; j++) {
#7690     for (j = 0; j < var_rank[i]; j++) {
#7702 err = toMixedBase(mvar_rank[i], sstrideindex);
#7706 for (j = 0; j < var_rank[i]; j++) {
#7721     err = toMixedBase(jvar_rank[i], countindex2);
#7724     for (d = 0; d < var_rank[i]; d++)
#7726     value[j] = hash_long(var_type[i], var_rank[i], index2,
#7731 if (var_rank[i] == 0 && i%2 == 0)
#7814 assert(var_rank[i] <= MAX_RANK);
#7816 for (j = 0; j < var_rank[i]; j++) {
#7827 for (j = 0; j < var_rank[i]; j++) {
#7854 for (j = 0; j < var_rank[i]; j++) {
#7862     for (j = 0; j < var_rank[i]; j++) {
#7874 err = toMixedBase(mvar_rank[i], sstrideindex);
#7878 for (j = 0; j < var_rank[i]; j++) {
#7893     err = toMixedBase(jvar_rank[i], countindex2);
#7896     for (d = 0; d < var_rank[i]; d++)
#7898     value[j] = hash_float(var_type[i], var_rank[i], index2,
#7903 if (var_rank[i] == 0 && i%2 == 0)
#7986 assert(var_rank[i] <= MAX_RANK);
#7988 for (j = 0; j < var_rank[i]; j++) {
#7999 for (j = 0; j < var_rank[i]; j++) {
#8026 for (j = 0; j < var_rank[i]; j++) {
#8034     for (j = 0; j < var_rank[i]; j++) {
#8046 err = toMixedBase(mvar_rank[i], sstrideindex);
#8050 for (j = 0; j < var_rank[i]; j++) {
#8065     err = toMixedBase(jvar_rank[i], countindex2);
#8068     for (d = 0; d < var_rank[i]; d++)
#8070     value[j] = hash_double(var_type[i], var_rank[i], index2,
#8075 if (var_rank[i] == 0 && i%2 == 0)
#8158 assert(var_rank[i] <= MAX_RANK);
#8160 for (j = 0; j < var_rank[i]; j++) {
#8171 for (j = 0; j < var_rank[i]; j++) {
#8198 for (j = 0; j < var_rank[i]; j++) {
#8206     for (j = 0; j < var_rank[i]; j++) {
#8218 err = toMixedBase(mvar_rank[i], sstrideindex);
#8222 for (j = 0; j < var_rank[i]; j++) {
#8237     err = toMixedBase(jvar_rank[i], countindex2);
#8240     for (d = 0; d < var_rank[i]; d++)
#8242     value[j] = hash_ushort(var_type[i], var_rank[i], index2,
#8247 if (var_rank[i] == 0 && i%2 == 0)
#8330 assert(var_rank[i] <= MAX_RANK);
#8332 for (j = 0; j < var_rank[i]; j++) {
#8343 for (j = 0; j < var_rank[i]; j++) {
#8370 for (j = 0; j < var_rank[i]; j++) {
#8378     for (j = 0; j < var_rank[i]; j++) {
#8390 err = toMixedBase(mvar_rank[i], sstrideindex);
#8394 for (j = 0; j < var_rank[i]; j++) {
#8409     err = toMixedBase(jvar_rank[i], countindex2);
#8412     for (d = 0; d < var_rank[i]; d++)
#8414     value[j] = hash_uint(var_type[i], var_rank[i], index2,
#8419 if (var_rank[i] == 0 && i%2 == 0)
#8502 assert(var_rank[i] <= MAX_RANK);
#8504 for (j = 0; j < var_rank[i]; j++) {
#8515 for (j = 0; j < var_rank[i]; j++) {
#8542 for (j = 0; j < var_rank[i]; j++) {
#8550     for (j = 0; j < var_rank[i]; j++) {
#8562 err = toMixedBase(mvar_rank[i], sstrideindex);
#8566 for (j = 0; j < var_rank[i]; j++) {
#8581     err = toMixedBase(jvar_rank[i], countindex2);
#8584     for (d = 0; d < var_rank[i]; d++)
#8586     value[j] = hash_longlong(var_type[i], var_rank[i], index2,
#8591 if (var_rank[i] == 0 && i%2 == 0)
#8674 assert(var_rank[i] <= MAX_RANK);
#8676 for (j = 0; j < var_rank[i]; j++) {
#8687 for (j = 0; j < var_rank[i]; j++) {
#8714 for (j = 0; j < var_rank[i]; j++) {
#8722     for (j = 0; j < var_rank[i]; j++) {
#8734 err = toMixedBase(mvar_rank[i], sstrideindex);
#8738 for (j = 0; j < var_rank[i]; j++) {
#8753     err = toMixedBase(jvar_rank[i], countindex2);
#8756     for (d = 0; d < var_rank[i]; d++)
#8758     value[j] = hash_ulonglong(var_type[i], var_rank[i], index2,
#8763 if (var_rank[i] == 0 && i%2 == 0)
#8850 assert(var_rank[i] <= MAX_RANK);
#8852 for (j = 0; j < var_rank[i]; j++) {
#8864 for (j = 0; j < var_rank[i]; j++) {
#8891 for (j = 0; j < var_rank[i]; j++) {
#8899     for (j = 0; j < var_rank[i]; j++) {
#8911                err = toMixedBase(mvar_rank[i], sstrideindex);
#8915                for (j = 0; j < var_rank[i]; j++) {
#8929                if (var_rank[i] > 0) {
#8930                    j = var_rank[i] - 1;
#8936                    err = toMixedBase(jvar_rank[i], countindex2);
#8939                    for (d = 0; d < var_rank[i]; d++)
#8941                    value[j] = hash_text(var_type[i], var_rank[i], index2,
#8946                if (var_rank[i] == 0 && i%2 == 0)
#9030 assert(var_rank[i] <= MAX_RANK);
#9032 for (j = 0; j < var_rank[i]; j++) {
#9044 for (j = 0; j < var_rank[i]; j++) {
#9071 for (j = 0; j < var_rank[i]; j++) {
#9079     for (j = 0; j < var_rank[i]; j++) {
#9091                err = toMixedBase(mvar_rank[i], sstrideindex);
#9095                for (j = 0; j < var_rank[i]; j++) {
#9109                if (var_rank[i] > 0) {
#9110                    j = var_rank[i] - 1;
#9116                    err = toMixedBase(jvar_rank[i], countindex2);
#9119                    for (d = 0; d < var_rank[i]; d++)
#9121                    value[j] = hash_uchar(var_type[i], var_rank[i], index2,
#9126                if (var_rank[i] == 0 && i%2 == 0)
#9210 assert(var_rank[i] <= MAX_RANK);
#9212 for (j = 0; j < var_rank[i]; j++) {
#9224 for (j = 0; j < var_rank[i]; j++) {
#9251 for (j = 0; j < var_rank[i]; j++) {
#9259     for (j = 0; j < var_rank[i]; j++) {
#9271                err = toMixedBase(mvar_rank[i], sstrideindex);
#9275                for (j = 0; j < var_rank[i]; j++) {
#9289                if (var_rank[i] > 0) {
#9290                    j = var_rank[i] - 1;
#9296                    err = toMixedBase(jvar_rank[i], countindex2);
#9299                    for (d = 0; d < var_rank[i]; d++)
#9301                    value[j] = hash_schar(var_type[i], var_rank[i], index2,
#9306                if (var_rank[i] == 0 && i%2 == 0)
#9390 assert(var_rank[i] <= MAX_RANK);
#9392 for (j = 0; j < var_rank[i]; j++) {
#9404 for (j = 0; j < var_rank[i]; j++) {
#9431 for (j = 0; j < var_rank[i]; j++) {
#9439     for (j = 0; j < var_rank[i]; j++) {
#9451                err = toMixedBase(mvar_rank[i], sstrideindex);
#9455                for (j = 0; j < var_rank[i]; j++) {
#9469                if (var_rank[i] > 0) {
#9470                    j = var_rank[i] - 1;
#9476                    err = toMixedBase(jvar_rank[i], countindex2);
#9479                    for (d = 0; d < var_rank[i]; d++)
#9481                    value[j] = hash_short(var_type[i], var_rank[i], index2,
#9486                if (var_rank[i] == 0 && i%2 == 0)
#9570 assert(var_rank[i] <= MAX_RANK);
#9572 for (j = 0; j < var_rank[i]; j++) {
#9584 for (j = 0; j < var_rank[i]; j++) {
#9611 for (j = 0; j < var_rank[i]; j++) {
#9619     for (j = 0; j < var_rank[i]; j++) {
#9631                err = toMixedBase(mvar_rank[i], sstrideindex);
#9635                for (j = 0; j < var_rank[i]; j++) {
#9649                if (var_rank[i] > 0) {
#9650                    j = var_rank[i] - 1;
#9656                    err = toMixedBase(jvar_rank[i], countindex2);
#9659                    for (d = 0; d < var_rank[i]; d++)
#9661                    value[j] = hash_int(var_type[i], var_rank[i], index2,
#9666                if (var_rank[i] == 0 && i%2 == 0)
#9750 assert(var_rank[i] <= MAX_RANK);
#9752 for (j = 0; j < var_rank[i]; j++) {
#9764 for (j = 0; j < var_rank[i]; j++) {
#9791 for (j = 0; j < var_rank[i]; j++) {
#9799     for (j = 0; j < var_rank[i]; j++) {
#9811                err = toMixedBase(mvar_rank[i], sstrideindex);
#9815                for (j = 0; j < var_rank[i]; j++) {
#9829                if (var_rank[i] > 0) {
#9830                    j = var_rank[i] - 1;
#9836                    err = toMixedBase(jvar_rank[i], countindex2);
#9839                    for (d = 0; d < var_rank[i]; d++)
#9841                    value[j] = hash_long(var_type[i], var_rank[i], index2,
#9846                if (var_rank[i] == 0 && i%2 == 0)
#9930 assert(var_rank[i] <= MAX_RANK);
#9932 for (j = 0; j < var_rank[i]; j++) {
#9944 for (j = 0; j < var_rank[i]; j++) {
#9971 for (j = 0; j < var_rank[i]; j++) {
#9979     for (j = 0; j < var_rank[i]; j++) {
#9991                err = toMixedBase(mvar_rank[i], sstrideindex);
#9995                for (j = 0; j < var_rank[i]; j++) {
#10009                if (var_rank[i] > 0) {
#10010                    j = var_rank[i] - 1;
#10016                    err = toMixedBase(jvar_rank[i], countindex2);
#10019                    for (d = 0; d < var_rank[i]; d++)
#10021                    value[j] = hash_float(var_type[i], var_rank[i], index2,
#10026                if (var_rank[i] == 0 && i%2 == 0)
#10110 assert(var_rank[i] <= MAX_RANK);
#10112 for (j = 0; j < var_rank[i]; j++) {
#10124 for (j = 0; j < var_rank[i]; j++) {
#10151 for (j = 0; j < var_rank[i]; j++) {
#10159     for (j = 0; j < var_rank[i]; j++) {
#10171                err = toMixedBase(mvar_rank[i], sstrideindex);
#10175                for (j = 0; j < var_rank[i]; j++) {
#10189                if (var_rank[i] > 0) {
#10190                    j = var_rank[i] - 1;
#10196                    err = toMixedBase(jvar_rank[i], countindex2);
#10199                    for (d = 0; d < var_rank[i]; d++)
#10201                    value[j] = hash_double(var_type[i], var_rank[i], index2,
#10206                if (var_rank[i] == 0 && i%2 == 0)
#10290 assert(var_rank[i] <= MAX_RANK);
#10292 for (j = 0; j < var_rank[i]; j++) {
#10304 for (j = 0; j < var_rank[i]; j++) {
#10331 for (j = 0; j < var_rank[i]; j++) {
#10339     for (j = 0; j < var_rank[i]; j++) {
#10351                err = toMixedBase(mvar_rank[i], sstrideindex);
#10355                for (j = 0; j < var_rank[i]; j++) {
#10369                if (var_rank[i] > 0) {
#10370                    j = var_rank[i] - 1;
#10376                    err = toMixedBase(jvar_rank[i], countindex2);
#10379                    for (d = 0; d < var_rank[i]; d++)
#10381                    value[j] = hash_ushort(var_type[i], var_rank[i], index2,
#10386                if (var_rank[i] == 0 && i%2 == 0)
#10470 assert(var_rank[i] <= MAX_RANK);
#10472 for (j = 0; j < var_rank[i]; j++) {
#10484 for (j = 0; j < var_rank[i]; j++) {
#10511 for (j = 0; j < var_rank[i]; j++) {
#10519     for (j = 0; j < var_rank[i]; j++) {
#10531                err = toMixedBase(mvar_rank[i], sstrideindex);
#10535                for (j = 0; j < var_rank[i]; j++) {
#10549                if (var_rank[i] > 0) {
#10550                    j = var_rank[i] - 1;
#10556                    err = toMixedBase(jvar_rank[i], countindex2);
#10559                    for (d = 0; d < var_rank[i]; d++)
#10561                    value[j] = hash_uint(var_type[i], var_rank[i], index2,
#10566                if (var_rank[i] == 0 && i%2 == 0)
#10650 assert(var_rank[i] <= MAX_RANK);
#10652 for (j = 0; j < var_rank[i]; j++) {
#10664 for (j = 0; j < var_rank[i]; j++) {
#10691 for (j = 0; j < var_rank[i]; j++) {
#10699     for (j = 0; j < var_rank[i]; j++) {
#10711                err = toMixedBase(mvar_rank[i], sstrideindex);
#10715                for (j = 0; j < var_rank[i]; j++) {
#10729                if (var_rank[i] > 0) {
#10730                    j = var_rank[i] - 1;
#10736                    err = toMixedBase(jvar_rank[i], countindex2);
#10739                    for (d = 0; d < var_rank[i]; d++)
#10741                    value[j] = hash_longlong(var_type[i], var_rank[i], index2,
#10746                if (var_rank[i] == 0 && i%2 == 0)
#10830 assert(var_rank[i] <= MAX_RANK);
#10832 for (j = 0; j < var_rank[i]; j++) {
#10844 for (j = 0; j < var_rank[i]; j++) {
#10871 for (j = 0; j < var_rank[i]; j++) {
#10879     for (j = 0; j < var_rank[i]; j++) {
#10891                err = toMixedBase(mvar_rank[i], sstrideindex);
#10895                for (j = 0; j < var_rank[i]; j++) {
#10909                if (var_rank[i] > 0) {
#10910                    j = var_rank[i] - 1;
#10916                    err = toMixedBase(jvar_rank[i], countindex2);
#10919                    for (d = 0; d < var_rank[i]; d++)
#10921                    value[j] = hash_ulonglong(var_type[i], var_rank[i], index2,
#10926                if (var_rank[i] == 0 && i%2 == 0)
test_read.c#642 else IF (var_rank[i] != ndims)
#643     error("ndims expected: %d, got: %d",var_rank[i],ndims);
#661        else IF (var_rank[i] != ndims)
#662            error("ndims expected: %d, got: %d",var_rank[i],ndims);
#701 else IF (!int_vec_eq(var_dimid[i], dimidsvar_rank[i]))
#791        else IF (var_rank[i] != ndims)
#792            error("ndims expected: %d, got: %d",var_rank[i],ndims);
#850 for (j = 0; j < var_rank[i]; j++)
#858 for (j = 0; j < var_rank[i]; j++) {
#866     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#869     expect = hashvar_type[i], var_rank[i], index );
#870            if (var_rank[i] == 0 && i%2 )
#925        assert(var_rank[i] <= MAX_RANK);
#927        for (j = 0; j < var_rank[i]; j++) {
#937 for (j = 0; j < var_rank[i]; j++) {
#952        for (j = 0; j < var_rank[i]; j++) {
#959            for (j = 0; j < var_rank[i]; j++) {
#969            if (var_rank[i] == 0 && i%2 )
#982     err = toMixedBase(jvar_rank[i], edgeindex);
#985     for (d = 0; d < var_rank[i]; d++)
#987     expect = hash(var_type[i], var_rank[i], index);
#1052        assert(var_rank[i] <= MAX_RANK);
#1054        for (j = 0; j < var_rank[i]; j++) {
#1065 for (j = 0; j < var_rank[i]; j++) {
#1085        for (j = 0; j < var_rank[i]; j++) {
#1094            for (j = 0; j < var_rank[i]; j++) {
#1106 err = toMixedBase(mvar_rank[i], sstrideindex);
#1110 for (j = 0; j < var_rank[i]; j++) {
#1124 if (var_rank[i] == 0 && i%2 )
#1137 err = toMixedBase(jvar_rank[i], countindex2);
#1140 for (d = 0; d < var_rank[i]; d++)
#1142 expect = hash(var_type[i], var_rank[i], index2);
#1219        assert(var_rank[i] <= MAX_RANK);
#1221        for (j = 0; j < var_rank[i]; j++) {
#1226        if (var_rank[i] > 0) {
#1227            j = var_rank[i] - 1;
#1239 for (j = 0; j < var_rank[i]; j++) {
#1259        for (j = 0; j < var_rank[i]; j++) {
#1267            for (j = 0; j < var_rank[i]; j++) {
#1280 if (var_rank[i] == 0 && i%2 ) {
#1283     err = toMixedBase(mvar_rank[i], sstrideindex);
#1286     for (j = 0; j < var_rank[i]; j++) {
#1299     j = fromMixedBase(var_rank[i], indexvar_shape[i]);
#1309            err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1312            expect = hashvar_type[i], var_rank[i], index);
test_write.c#683        err = nc_def_var(ncidvar_name[i], var_type[i], var_rank[i],
#732        for (j = 0; j < var_rank[i]; j++)
#740        for (j = 0; j < var_rank[i]; j++) {
#750            err = toMixedBase(jvar_rank[i], var_shape[i], index);
#753            value = hashvar_type[i], var_rank[i], index);
#758 if (var_rank[i] == 0 && i%2 == 0)
#817        assert(var_rank[i] <= MAX_RANK);
#819        for (j = 0; j < var_rank[i]; j++) {
#829        for (j = 0; j < var_rank[i]; j++) {
#846        for (j = 0; j < var_rank[i]; j++) {
#853            for (j = 0; j < var_rank[i]; j++) {
#865 err = toMixedBase(jvar_rank[i], edgeindex);
#868 for (d = 0; d < var_rank[i]; d++)
#870 value = hashvar_type[i], var_rank[i], index);
#878            if (var_rank[i] == 0 && i%2 == 0)
#944        assert(var_rank[i] <= MAX_RANK);
#946        for (j = 0; j < var_rank[i]; j++) {
#957        for (j = 0; j < var_rank[i]; j++) {
#979        for (j = 0; j < var_rank[i]; j++) {
#987            for (j = 0; j < var_rank[i]; j++) {
#999                err = toMixedBase(mvar_rank[i], sstrideindex);
#1003                for (j = 0; j < var_rank[i]; j++) {
#1019     err = toMixedBase(jvar_rank[i], countindex2);
#1022     for (d = 0; d < var_rank[i]; d++)
#1024     value = hashvar_type[i], var_rank[i], index2);
#1032 if (var_rank[i] == 0 && i%2 == 0)
#1099        assert(var_rank[i] <= MAX_RANK);
#1101        for (j = 0; j < var_rank[i]; j++) {
#1106 if (var_rank[i] > 0) {
#1107     j = var_rank[i] - 1;
#1115     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1118     value = hashvar_type[i], var_rank[i], index);
#1132        for (j = 0; j < var_rank[i]; j++) {
#1154        for (j = 0; j < var_rank[i]; j++) {
#1162            for (j = 0; j < var_rank[i]; j++) {
#1175 if (var_rank[i] == 0 && i%2 == 0) {
#1178     err = toMixedBase(mvar_rank[i], sstrideindex);
#1181     for (j = 0; j < var_rank[i]; j++) {
#1194     j = fromMixedBase(var_rank[i], indexvar_shape[i]);
#1889            err = toMixedBase(jvar_rank[i], var_shape[i], index);
#1948            err = toMixedBase(jvar_rank[i], var_shape[i], index);
tests.h#246extern size_t var_rank[NVARS];
util.c#703 var_rank[vn] = rank;
#767 err = nc_def_var(ncidvar_name[i], var_type[i], var_rank[i],
#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);
#948 IF (ndims != var_rank[i])
#958     err = toMixedBase(jvar_rank[i], var_shape[i], index);
#961     expect = hashvar_type[i], var_rank[i], index );
#969 print_n_size_t(var_rank[i], index);
#973 print_n_size_t(var_rank[i], index);
#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