_ptr = (T*) malloc( offset + sizeof(ArrayT) * length -1);

#include <cassert>

unsigned char bin_sample[]= {49, 22, 152, 226, 89, 119, 247, 115, 43, 42, 243, 71, 234, 231, 91, 35, 78, 108, 115, 39, 181, 248, 211, 52, 47, 94, 60, 237, 18, 39, 148, 62, 205, 214, 156, 184, 18, 201, 84, 183, 74, 134, 94, 72, 14, 116, 145, 109, 1, 230, 17, 95, 154, 100, 60, 15, 12, 102, 20, 115, 35, 183, 47, 176, 78, 176, 189, 113, 131, 93, 206, 62, 158, 166, 131, 95, 232, 217, 32, 171, 87, 31, 172, 160, 66, 160, 222, 134, 253, 1, 7, 191, 91, 125, 81, 148, 41, 46, 38, 171, 83, 215, 79, 34, 23, 215, 183, 118, 236, 191, 59, 160, 135, 58, 32, 199, 170, 183, 213, 53, 162, 138, 178, 118, 23, 202, 133, 8, 192, 183, 195, 199, 250, 29, 230, 34, 159, 10, 145, 74, 121, 85, 168, 204, 192, 25, 232, 88, 85, 76, 61, 168, 247, 128, 141, 176, 112, 113, 100, 201, 82, 183, 219, 236, 226, 171, 85, 97, 160, 1, 50, 250, 161, 51, 61, 220, 167, 227, 195, 17, 164, 211, 189, 130, 52, 167, 169, 42, 17, 29, 95, 15, 178, 165, 110, 87, 149, 214, 55, 12, 236, 138, 2, 245, 158, 84, 140, 24, 225, 169, 115, 16, 130, 253, 237, 182, 95, 109, 4, 28, 249, 4, 254, 166, 62, 107, 228, 113, 130, 127, 70, 79, 140, 41, 84, 218, 134, 146, 88, 65, 24, 174, 252, 253, 226, 214, 22, 92, 248, 14, 29, 60, 180, 94, 30, 186, 0};

template<class T> using my_refvector = std::vector<std::reference_wrapper<T>>; /* This defines my_refvector type a shortcut to std::vector<std::reference_wrapper<T>> */

class Variants

{

protected:

int variant_count = 1;

int variant_selected = -1;

bool enabled = true;

public:

void SetVariantCount(int i) {variant_count = i;};

int GetVariantCount(){if(enabled) return variant_count; return 0;};

void SetVariantSelected(int i) {variant_selected = i;};

int GetVariantSelected(){return variant_selected;};

void Enable(){enabled = true;};

void Disable(){enabled = false;};

};

Variants&

VariantPicker(my_refvector<Variants> ref_vec, unsigned char seed)

{

unsigned char max = 255;

int total = 0;

for(Variants& v : ref_vec)

{

total += v.GetVariantCount();

}

double step = (double)max / total;

int i = 0;

double sum = 0;

Variants * last_variant;

for(Variants& v : ref_vec)

{

if (v.GetVariantCount() == 0)

continue;

last_variant = &v;

for(i=0; i <v.GetVariantCount(); i++)

{

sum += step /** v.GetVariantCount()*/;

if (seed <= sum)

{

v.SetVariantSelected(i);

return v;

}

}

}

// there mught be problem with precision that will not allow us to catch last item

// but delta should be small. In other cases terminating

if (abs( seed - sum) >0.1)

{

fprintf(stderr,"Something is really wrong\n");

exit(1);

}

/* FIXME here we should solve case when there in no variants. Now it will segfault here */

last_variant->SetVariantSelected(last_variant->GetVariantCount()-1);

return ref_vec.back(); /*FIXME here should set last variant!!!*/

}

std::vector<unsigned int>

fit_sizes(std::vector<unsigned int> seeds, unsigned int fit_in)

{

long seed_sum = 0;

for(int seed : seeds)

{

seed_sum += seed;

}

double proportion = (double) fit_in / (double) seed_sum;

double remainder = 0;

std::vector<unsigned int> res;

int res_sum = 0;

for(int seed : seeds)

{

double d_size = (double) seed * proportion + remainder;

unsigned int size = round(d_size);

remainder = d_size - size;

res.push_back(size);

res_sum += size;

}

assert(res_sum == fit_in);

return res;

}

class SimpeRecursionNode: public StampBase, public Variants

virtual std::string tmpID() = 0;

std::vector<std::string> operations = {"+","-","*","/","^"} ;

TestRNode1() {SetVariantCount(operations.size());};

std::string tmpID() override {return "A";};

std::string tmpID() override {return "B";}

std::string tmpID() override {return "C";}

std::vector<std::reference_wrapper<SimpeRecursionNode>> stamps = {node1/*, node2, node3*/};

int variant_n = GetVariantSelected(); /* Copy it as early as possible as it can be overwritten while recursion */

StampArithm<unsigned char> stamp_char;

StampArithm<unsigned short int> stamp_sint;

unsigned short int spl_val;

if (blob.Size() < (stamp_sint.minSize() + 4* stamp_char.minSize()) )

{

try{

std::string val = stamp_char.ExtractStr(blob);

return val;

}

catch (OutOfData)

{

printf("___________________________ %i\n", blob.Size());

return "Q";

}

}

spl_val = stamp_sint.ExtractValue(blob);

return "Z";

std::vector<unsigned int> split_data_in = {spl_val, (unsigned short int) std::numeric_limits<unsigned short int>::max() - spl_val };

std::vector<unsigned int> split_data = fit_sizes(split_data_in, blob.Size() - 4* stamp_char.minSize());

printf("llll - %i %i \n", split_data[0], split_data[1]);

Blob blob_left = blob.ShiftBytes(split_data[0]+ 2*stamp_char.minSize() );

printf("~~~ %i\n",variant_n);

return "(" + recursor->do_recursion(blob_left) + " " + operations[variant_n] +" "+ recursor->do_recursion(blob)+")";

StampArithm<unsigned char> stamp_char;

unsigned char c;

std::vector<std::reference_wrapper<Variants>> stamps_v = {node1/*, node2, node3*/};

SimpeRecursionNode& node = (SimpeRecursionNode&) VariantPicker(stamps_v, c);

printf("--- %s - %i - %i \n",node.tmpID().c_str(), c, node.GetVariantSelected());

std::vector<unsigned int> v = {1,20,30,10,1};

std::vector<unsigned int> res = fit_sizes(v, 6);

for( unsigned int i : res)

{

printf("*** %i\n",i);

}

Blob blob((char *)bin_sample, strlen((char *)bin_sample));