#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <float.h>
#include <math.h>
#include <errno.h>

#define MAX_SIZE UINT32_MAX
//#define MAX_SIZE 30
#define RANGES 4
#define ALGS 8

//struct Alg_Data{
//uint16_t a[ALGS];
//};

int main(int argc, char **argv){
	//const unsigned char perm_4[4096][4] = {
	//{0,0,0,0},
	//...
	//{0,0,0,0}
	//};
	uint32_t a, b, c, d;
/*
	uint32_t min_a = 1;
	uint32_t min_b = 2;
	uint32_t min_c = 3;
	uint32_t min_d = 4;
	uint32_t max_a = MAX_SIZE-3;
	uint32_t max_b = MAX_SIZE-2;
	uint32_t max_c = MAX_SIZE-1;
	uint32_t max_d = MAX_SIZE;
*/
	uint32_t comb_a = 0;
	uint32_t comb_b = 0;
	uint32_t comb_t_a = 0;
	uint32_t comb_t_b = 0;
        const uint32_t min_start_a = 0;
        const uint32_t min_start_b = 1;
        const uint32_t min_start_c = 2;
        const uint32_t min_start_d = 3;
        const uint32_t max_end_d = MAX_SIZE;
	uint64_t Threads = 1;

	uint64_t slice_a = (uint64_t)(pow(MAX_SIZE, 3)/6 - pow(MAX_SIZE, 2)/2 + MAX_SIZE/3) / Threads;

printf("%zu\n", FLT_MAX);
printf("%zu\n", DBL_MAX);


Threads = (uint64_t)pow(MAX_SIZE, 3);
if(errno == EDOM)
	printf("pow: domain error\n");
else if(errno == ERANGE)
	printf("pow: pole or range error\n");

	printf("%zu\n", slice_a);

/*
	for(d=min_start_d; d<max_end_d; d++){
		for(c=min_start_c; c<d; c++){
			comb_b++;
			for(b=min_start_b; b<c; b++){
				comb_a++;
//				for(a=min_start_a; a<b; a++){
//					combinations++;
//				}
			}
		}
		printf("%u %u %u\n", d, comb_b, comb_a);
		comb_t_a += comb_a;
		comb_t_b += comb_b;
		comb_a = 0;
		comb_b = 0;

	}
	printf("%u %u\n", comb_t_a, comb_t_b);
*/
//printf("%u\n", FLT_MAX);

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

/*
	for(d=min_d; d<max_d; d++){
		for(c=min_c; c<d ; c++){
			combinations += c-min_b;

//4.1 billion times here
//4116152316		process array[MAX_SIZE][ALGS]

//			combinations += b-min_a;
//			for(a=min_a; a<b ; a++){
//				combinations++;
//			}
		}
	}
	printf("%u\n", combinations);


	for(d=0; d<max_d; d++){
		//count rolling totals
	}
	for(c=min_c; c<max_c; c++){
		//calculate a/b
		for(alg=0; alg<ALGS; alg++){
			a[alg] = totals[b][alg]
		}
		for(a=min_a; a<(c-2); a++){
			//total_b = totals_c - totals_a

		}
		for(b=min_b; b<c; b++){
			//rolling total - b = a

		}
		//calculate c/d
		//rolling total - d = d
		//rolling total leftover = c
	}

*/

/*
        uint16_t wins[RANGES][ALGS];
        uint16_t wins_T[RANGES][ALGS] = {{1,2},{3,4}};

        (void)memset((void *)wins, '\0', sizeof(uint16_t)*RANGES*ALGS);
        //(void)memset((void *)wins_T, '\0', sizeof(uint16_t)*RANGES*ALGS);

	(void)memcpy((void *)&wins[1][0], (const void *)&wins_T[0][0], sizeof(uint16_t)*ALGS);
	for(a=0, d=4, c=4; a<RANGES; a++){
		for(b=0; b<ALGS; b++){
			printf("%u\n", wins[a][b]);
		}
	}
	printf("%u %u\n", c,d);

	printf("const unsigned char perm_4[4096][4] = {\n");
//	for(num1=0; num1<4096; num1++){

	for(a=0; a<8; a++){
		for(b=0; b<8; b++){
			for(c=0; c<8; c++){
				for(d=0; d<8; d++){
					printf("{%u,%u,%u,%u},\n", a, b, c, d);
				}
			}
		}
	}
*/
	return 0;
}