/*
 *  OGRdist.c
 *  
 *
 *  Created by Michael Feiri on Mon Sep 09 2002.
 *  Copyright (c) 2002 __MyCompanyName__. All rights reserved.
 *
 */

unsigned int newOGRdist32[32];
unsigned int newOGRdist64[32];
unsigned int newOGRdist96[32];
unsigned int newOGRdist128[32];
unsigned int newOGRdist160[32];
unsigned int newOGRdist192[32];
unsigned int newOGRdist224[32];
int OGRdistCount;

#define STORE_DIST									\
{											\
    unsigned int dist32=0;								\
    unsigned int dist64=0;								\
    unsigned int dist96=0;								\
    unsigned int dist128=0;								\
    unsigned int dist160=0;								\
    unsigned int dist192=0;								\
    unsigned int dist224=0;								\
    for (i=1; i <= maxmarks; i++) {							\
        for (j=0; j<i; j++) {								\
            int diff = count[i]-count[j];						\
            if (diff<=32 ) {dist32 = dist32 | (0x80000000>>(diff-1));}			\
            if ((diff>32)&&(diff<=64)) {dist64 = dist64 | (0x80000000>>(diff-33));}	\
            else if ((diff>64)&&(diff<=96)) {dist96 = dist96 | (0x80000000>>(diff-65));}	\
            else if ((diff>96)&&(diff<=128)) {dist128 = dist128 | (0x80000000>>(diff-97));}	\
            else if ((diff>128)&&(diff<=160)) {dist160 = dist160 | (0x80000000>>(diff-129));}	\
            else if ((diff>160)&&(diff<=192)) {dist192 = dist192 | (0x80000000>>(diff-161));}	\
            else if ((diff>192)&&(diff<=224)) {dist224 = dist224 | (0x80000000>>(diff-193));}	\
        }										\
    }											\
    for(i=0; i<=maxmarks; i++ ) printf("%4d",count[i]);printf("!"); fflush(0);	\
    newOGRdist32[OGRdistCount]=newOGRdist32[OGRdistCount]&dist32;				\
    newOGRdist64[OGRdistCount]=newOGRdist64[OGRdistCount]&dist64;				\
    newOGRdist96[OGRdistCount]=newOGRdist96[OGRdistCount]&dist96;				\
    newOGRdist128[OGRdistCount]=newOGRdist128[OGRdistCount]&dist128;				\
    newOGRdist160[OGRdistCount]=newOGRdist160[OGRdistCount]&dist160;				\
    newOGRdist192[OGRdistCount]=newOGRdist192[OGRdistCount]&dist192;				\
    newOGRdist224[OGRdistCount]=newOGRdist224[OGRdistCount]&dist224;				\
        if ((newOGRdist32[OGRdistCount]==0) && (newOGRdist64[OGRdistCount]==0) && 			\
            (newOGRdist96[OGRdistCount]==0) && (newOGRdist128[OGRdistCount]==0) && 			\
            (newOGRdist160[OGRdistCount]==0) && (newOGRdist192[OGRdistCount]==0) && 			\
            (newOGRdist224[OGRdistCount]==0)) return 0;		\
}

#define AS_MODULE
#include "halfTweaked4GARSP_MODU.c" // insert a call in foundone() to store the results!!!

int main() {
    
    const int count[32][32] = {
        /*OGR-1*/ {0},
        /*OGR-2*/ {0,1},
        /*OGR-3*/ {0,1,3},
        /*OGR-4*/ {0,1,4,6},
        /*OGR-5*/ {0,1,4,9,11}, /* NOT UNIQUE */
        /*OGR-6*/ {0,1,4,10,12,17}, /* NOT UNIQUE */
        /*OGR-7*/ {0,1,4,10,18,23,25}, /* NOT UNIQUE */
        /*OGR-8*/ {0,1,4,9,15,22,32,34},
        /*OGR-9*/ {0,3,9,17,19,32,39,43,44},
        /*OGR-10*/{0,1,6,10,23,26,34,41,53,55},
        /*OGR-11*/{0,1,4,13,28,33,47,54,64,70,72}, /* NOT UNIQUE */
        /*OGR-12*/{0,2,6,24,29,40,43,55,68,75,76,85},
        /*OGR-13*/{0,7,8,17,21,36,47,63,69,81,101,104,106},
        /*OGR-14*/{0,5,28,38,41,49,50,68,75,92,107,121,123,127},
        /*OGR-15*/{0,6,7,15,28,40,51,75,89,92,94,121,131,147,151},
        /*OGR-16*/{0,1,4,11,26,32,56,68,76,115,117,134,150,163,168,177},
        /*OGR-17*/{0,5,7,17,52,56,67,80,81,100,122,138,159,165,168,191,199},
        /*OGR-18*/{0,2,10,22,53,56,82,83,89,98,130,148,153,167,188,192,205,216},
        /*OGR-19*/{0,4,13,15,42,56,59,77,93,116,126,138,146,174,214,221,240,245,246},
        /*OGR-20*/{0,24,30,43,55,71,75,89,104,125,127,162,167,189,206,215,272,275,282,283},
        /*OGR-21*/{0,4,23,37,40,48,68,78,138,147,154,189,204,238,250,251,256,277,309,331,333},
        /*OGR-22*/{0,1,9,14,43,70,106,122,124,128,159,179,204,223,253,263,270,291,330,341,353,356},
        /*OGR-23*/{0,6,22,24,43,56,95,126,137,146,172,173,201,213,258,273,281,306,311,355,365,369,372},
        /*OGR-24*/{0,9,33,37,38,97,122,129,140,142,152,191,205,208,252,278,286,326,332,353,368,384,403,425}, /* UNPROVEN */
        /*OGR-25*/{0,12,29,39,72,91,146,157,160,161,166,191,207,214,258,290,316,354,372,394,396,431,459,467,480}, /* UNPROVEN */
        /*OGR-26*/{0,1,33,83,104,110,124,163,185,200,203,249,251,258,314,318,343,356,386,430,440,456,464,475,487,492}, /* UNPROVEN */
        /*OGR-27*/{0,3,15,41,66,95,97,106,142,152,220,221,225,242,295,330,338,354,382,388,402,415,486,504,523,546,553}, /* UNPROVEN */
        /*OGR-28*/{0,3,15,41,66,95,97,106,142,152,220,221,225,242,295,330,338,354,382,388,402,415,486,504,523,546,553,585}, /* UNPROVEN, ~= OGR-27! */
        /*OGR-29*/{0,3,28,33,41,95,156,158,193,207,233,252,267,338,339,355,394,403,421,473,479,502,523,570,580,592,612,616,623}, /* UNPROVEN */
        /*OGR-30*/{0,9,35,57,128,149,151,180,205,218,281,292,336,364,370,378,394,469,473,474,514,533,580,595,598,631,641,648,666,680}, /* UNPROVEN */
        /*OGR-31*/{0,9,12,54,79,143,145,161,192,205,226,311,349,363,382,386,439,459,466,474,502,560,561,571,601,669,675,701,725,730,747}, /* UNPROVEN */
        /*OGR-32*/{0,7,15,26,28,57,112,118,136,176,177,181,211,214,258,309,318,341,389,403,456,476,512,528,582,628,671,696,745,762,772,784} /* UNPROVEN */
    };
    const int OGR[32] = { /*  1 */    0,   1,   3,   6,  11,  17,  25,  34,  44,  55,  72,
        /* 12 */   85, 106, 127, 151, 177, 199, 216, 246, 283, 333, 356,
        /* 23 */  372, 425, 480, 492, 553, 585, 623, 680, 747, 784 };
    int h,i,j;
    
    for (h=0; h < 32 /* Configured for up to OGR-32 */ ; h++) {
        unsigned int dist = 0;
        printf("/* OGR-%02d ",h+1);
        for (i=1; i <= h; i++) {
            for (j=0; j<i; j++) {
                int diff = count[h][i]-count[h][j];
                if (diff<=32 /* sizeof(dist) */ ) {dist = dist | (0x80000000>>(diff-1));}
                //binary(dist);printf("delta %d (count[i]-count[j]=%d-%d)\n",diff,count[h][i],count[h][j]);
            }
        }
         binary(dist);
         printf(" */ 0x%08x,\n",dist);
    }

         printf("\n");

//         for (h=18;h<19;h++) {
//         //for (h=11;h<12;h++) {
//             OGRdistCount = 11; for (i=0;i<32;i++) {newOGRdist[i]=0;}
//             printf("/* OGR-%d */\n",h+1);
//             printf("halfTweakedGARSP(%d,%d+%d)",h,OGR[h],OGRdistCount); fflush(0);
//             while(halfTweakedGARSP(h,OGR[h]+OGRdistCount)!=0) {/**/printf("\n/* ");
//              binary(newOGRdist[OGRdistCount]); printf(" */ 0x%08x",newOGRdist[OGRdistCount]);
//              printf("\nhalfTweakedGARSP(%d,%d+%d)",h,OGR[h],++OGRdistCount); fflush(0);}
//             printf("\n\n/* OGR-%d */ {\n",h+1);
//             for (i=0;i<32;i++) {printf("/* "); binary(newOGRdist[i]); printf(" */ 0x%08x,\n",newOGRdist[i]);}
//             printf("},\n\n");
//             }

         for (h=17;h<18;h++) {
             OGRdistCount = 22/*11*/; for (i=0;i<32;i++) {
                 newOGRdist32[i]=0xffffffff;newOGRdist64[i]=0xffffffff;newOGRdist96[i]=0xffffffff;newOGRdist128[i]=0xffffffff;
                 newOGRdist160[i]=0xffffffff;newOGRdist192[i]=0xffffffff;newOGRdist224[i]=0xffffffff;
             } printf("\n\n/* OGR-%d */\n",h+1);

             do {
             printf("halfTweakedGARSP(%d,%d+%d)",h,OGR[h],OGRdistCount); fflush(0);
             if (halfTweakedGARSP(h,OGR[h]+OGRdistCount)==0) {printf("halfTweakedGARSP aborted"); break;}
             printf("\n/* "); binary(newOGRdist32[OGRdistCount]); printf(" */ 0x%08x // ",newOGRdist32[OGRdistCount]);
             printf("/* "); binary(newOGRdist64[OGRdistCount]); printf(" */ 0x%08x    ",newOGRdist64[OGRdistCount]);
             printf("/* "); binary(newOGRdist96[OGRdistCount]); printf(" */ 0x%08x    ",newOGRdist96[OGRdistCount]);
             printf("/* "); binary(newOGRdist128[OGRdistCount]); printf(" */ 0x%08x    ",newOGRdist128[OGRdistCount]);
             printf("/* "); binary(newOGRdist160[OGRdistCount]); printf(" */ 0x%08x    ",newOGRdist160[OGRdistCount]);
             printf("/* "); binary(newOGRdist192[OGRdistCount]); printf(" */ 0x%08x    ",newOGRdist192[OGRdistCount]);
             printf("/* "); binary(newOGRdist224[OGRdistCount]); printf(" */ 0x%08x\n",newOGRdist224[OGRdistCount]);
             ++OGRdistCount;
             } while ((newOGRdist32[OGRdistCount-1]!=0) || (newOGRdist64[OGRdistCount-1]!=0) ||
                      (newOGRdist96[OGRdistCount-1]!=0) || (newOGRdist128[OGRdistCount-1]!=0) ||
                      (newOGRdist160[OGRdistCount-1]!=0) || (newOGRdist192[OGRdistCount-1]!=0) ||
                      (newOGRdist224[OGRdistCount-1]!=0));
             
             //printf("\n\n/* OGR-%d */ {\n",h+1);
             //i=0; do {printf("/* "); binary(newOGRdist[i]); printf(" */ 0x%08x,\n",newOGRdist[i]);} while (newOGRdist[i++]!=0);
             //printf("},\n\n");
             }
         
    
    return 0;
}