Run with tilesize of 60, and corrected binary resonance.

--------------------------------------------------------------------------------
-- Auto-annotated source: /home/cstaley/PolyWork/CountInversions4.c
--------------------------------------------------------------------------------
         Ir I1mr ILmr          Dr      D1mr DLmr      Dw   D1mw DLmw 

-- line 9 ----------------------------------------
          .    .    .           .         .    .       .      .    .  typedef struct {
          .    .    .           .         .    .       .      .    .    long tag1;
          .    .    .           .         .    .       .      .    .    long tag2;
          .    .    .           .         .    .       .      .    .    char name1[NAME_LEN];
          .    .    .           .         .    .       .      .    .    char name2[NAME_LEN];
          .    .    .           .         .    .       .      .    .    char breakResonance[BR_PAD];
          .    .    .           .         .    .       .      .    .  } CacheHog;
          .    .    .           .         .    .       .      .    .  
          4    0    0           0         0    0       1      0    0  int main(int argc) {
          2    1    0           0         0    0       2      0    0     int i, j, numHogs, numInv1 = 0, numInv2 = 0;
          .    .    .           .         .    .       .      .    .     int tileSize, iBase, iLim, jBase, jLim;
          .    .    .           .         .    .       .      .    .     CacheHog *vals;
          .    .    .           .         .    .       .      .    .  
          7    1    1           0         0    0       4      0    0     scanf("%d %d", &numHogs, &tileSize);
          5    1    0           1         0    0       4      1    0     vals = calloc(sizeof(CacheHog), numHogs);
     40,005    1    1      30,002         0    0       1      0    0     for (i = 0; i < numHogs; i++) {
     90,000    1    0      40,000         0    0  10,000 10,000    0        vals[i].tag1 = numHogs - i;
     90,000    0    0      40,000         0    0  10,000      0    0        vals[i].tag2 = numHogs + i;
          .    .    .           .         .    .       .      .    .     }
          .    .    .           .         .    .       .      .    .  
        840    3    2         503         0    0     168      0    0     for (iBase = 0; iBase < numHogs; iBase = iLim) {
      1,169    0    0         501         0    0     167      0    0        iLim = iBase + tileSize < numHogs ? iBase + tileSize : numHogs; 
          .    .    .           .         .    .       .      .    .       
          .    .    .           .         .    .       .      .    .        // Check within the tile 
     41,002    2    1      30,501         0    0     167      0    0        for (i = iBase; i < iLim; i++)
  1,248,400    1    0     913,800         0    0  10,000      0    0           for (j = i+1; j < iLim; j++) {
  4,713,600    1    1   1,767,600     9,934    0       0      0    0              if (vals[i].tag1 > vals[j].tag1)
    294,600    1    0     294,600         0    0       0      0    0                 numInv1++;
  4,713,600    0    0   1,767,600         0    0       0      0    0              if (vals[i].tag2 > vals[j].tag2)
          .    .    .           .         .    .       .      .    .                 numInv2++;
          .    .    .           .         .    .       .      .    .           }
          .    .    .           .         .    .       .      .    .  
          .    .    .           .         .    .       .      .    .        // Check all following tiles, exhausting each completely wrt tile i
     70,307    1    1      42,084         0    0  14,028      0    0        for (jBase = iLim; jBase < numHogs; jBase = jLim) {
     97,027    0    0      41,583         0    0  13,861      0    0           jLim = jBase + tileSize < numHogs ? jBase + tileSize : numHogs;
  3,409,806    2    1   2,536,563         0    0  13,861      0    0           for (i = iBase; i < iLim; i++)
203,791,560    1    0 151,596,180         0    0 831,660      0    0              for (j = jBase; j < jLim; j++) {
795,206,400    1    1 298,202,400 1,528,352    0       0      0    0                 if (vals[i].tag1 > vals[j].tag1)
 49,700,400    1    0  49,700,400         0    0       0      0    0                    numInv1++;
795,206,400    0    0 298,202,400         0    0       0      0    0                 if (vals[i].tag2 > vals[j].tag2)
          .    .    .           .         .    .       .      .    .                    numInv2++;
          .    .    .           .         .    .       .      .    .              }
          .    .    .           .         .    .       .      .    .        }
          .    .    .           .         .    .       .      .    .     }
          .    .    .           .         .    .       .      .    .              
          7    1    0           2         0    0       4      0    0     printf("Inversion counts: %d %d \n", numInv1, numInv2);
          3    0    0           1         0    0       2      0    0     free(vals);
          .    .    .           .         .    .       .      .    .     
          1    0    0           0         0    0       0      0    0     return 0;
          2    0    0           2         0    0       0      0    0  }

--------------------------------------------------------------------------------