//a b c and d = starts of ranges in which we count the win total of 8 different values, compared to each other, for each range
for(a=3; a<32768; a++){
	for(b=2; b<a; b++){
		for(c=1; c<b; c++){
			d=0;
			//take the best win total from each range add them together and save if highest total yet
		}
	}
}

32768

32765*32765*32765


////// READ ABOVE HERE /////////

//rolling_t[max_end_d][ALGS+1]; //+1 for winner?

//a and b are always in direct relation
rolling_t[max_end_d]
min_start_b - max_start_c


struct A_B_TALLY{
uint16_t winner_a;
uint16_t winner_b;
uint16_t wins_a;
uint16_t wins_b;
uint16_t wins_t;
}tally_ab[max_start_c-min_start_b];



struct D_TALLY{
uint16_t winner;
uint16_t wins;
}tally_d[max_end_d-min_start_d];

for(a=0; a<32768; a++){
4*8 multiples
32765*32765*32765 permutations
}

for(start_d = min_start_d; start_d<max_end_d; start_d++){

	for(start_c = min_start_c; start_c<start_d; start_c++){

		for(start_b = min_start_b; start_b<start_c; start_b++){
			//if(tally_d[start_d].wins + tally_ab[].wins_t + wins_c > max_wins)
			wins_t = wins_d + wins_c + wins_b + wins_a;
		}
	}
}


//D
for(start_d = min_start_d; start_d<max_end_d; start_d++){
	(void)memcpy((void *)wins_Rc_t, (const void *)wins_Rc, sizeof(uint16_t)*ALGS);
//	(void)memcpy((void *)wins_Rb_t, (const void *)wins_Rb, sizeof(uint16_t)*ALGS);
//	(void)memcpy((void *) wins_Ra_t, (const void *) wins_Ra, sizeof(uint16_t)*ALGS);

//C
	for(start_c = min_start_c; start_c<start_d; start_c++){
//B
		(void)memcpy((void *) wins_Ra_t, (const void *) wins_Ra, sizeof(uint16_t)*ALGS);
		(void)memcpy((void *)wins_Rb_t, (const void *)wins_Rb, sizeof(uint16_t)*ALGS);
		for(start_b = min_start_b; start_b<start_c; start_b++){

//A  shouldn't be here
//			for(start_a = min_start_a; start_a<start_b; start_a++){
//
//				wins_Ra_t[fastest[start_b]]++;
//			}

// calc cur_win save max_win



			wins_Rb_t[fastest[start_b]]--; //loss on start
			wins_Ra_t[fastest[start_b]]++; // gain on end
		}
		wins_Rc_t[fastest[start_c]]--; //loss on start
		wins_Rb_t[fastest[start_c]]++;   // gain on end
	}
	wins_Rd[fastest[start_d]]--; //loss on start
	wins_Rc[fastest[start_d]]++; //gain on end
}