weird

8/34 = 4/17
4/17 = 0.23529411764705882 = [0;4,4]
13/34 = 0.38235294117647056 = [0;2,1,1,1,1,2]
21/34 = 0.6176470588235294 = [0;1,1,1,1,1,1,2]

from

8: 2 1 1 1 3
13: 2 1 1 3 1
21: 1 1 1 1 1 1 2

total is 34

Weird 2

int zeros = 10;
int ones = 10;

for(int i = 0; i < 20; i++)

gives difference is powers of 2 even after and and xor61

0 00000000001111111111 20 512
1 00000000010111111111 20 768
2 00000000011011111111 20 896
3 00000000011101111111 20 960
4 00000000011110111111 20 992
5 00000000011111011111 20 1008

322 and 161 mod 23 and mod 7 same lol

Saw it again but with bigger values. I think i know how to divide by 2. 94 to 93 bits. 
(275,20)1110110001011110001111011111010111100100001110000000000000100000011110110001101110110001100100 (0 2)(1 3)(6 7)(11 13)(3 17)(28 29)(0 37)(42 43)(40 53)(37 67)(39 89)(0 127)(16 131)(136 257)(254 263)(108 269)(194 271)

(275,20)111011000101111000111101111101011110010000111000000000000010000001111011000110111011000110010 (0 2)(2 3)(3 7)(12 13)(10 17)(14 29)(0 37)(21 43)(20 53)(52 67)(64 89)(0 127)(8 131)(68 257)(127 263)(54 269)(97 271)
int *BinToModList(int *binary, int binaryLength, int primeLength)
{
 int *mods = calloc(primeLength,sizeof(int));
 mods[0] = binary[binaryLength-1];
 for(int i = 1; i < primeLength; i++)
 {
  int r = BinaryToMod(binary,binaryLength,first5239[i]); 
  mods[i] = r;  
 }
 return mods;
}
int PrimeLog(int primeLength)
{
 double logSum = 0;
 for(int i = 0; i < primeLength; i++)
 {
  logSum += log2(first5239[i]);
  
 }
 return (int)floor(logSum)-7;
}
void RemoveLastBit(int *mods, int modLength, int bit)
{
 if(bit == 0)
 {
  for(int i = 0; i < modLength; i++)
  {
   if(mods[i] % 2 == 0)//If mod value is odd
   {
    mods[i] /= 2;
   }
   else
   {
    mods[i] = ((first5239[i] + mods[i])/2);
   }
  }
 }
 else
 {
  for(int i = 1; i < modLength; i++)
  {
   if(mods[i] % 2 == 0)//If mod value is even
   {
    mods[i] = ((first5239[i] + mods[i])/2);
   }
   else
   {
    mods[i] /= 2;
   }
  }
 }
}
void ReturnLastZero(int *mods, int modLength)
{
 for(int i = 0; i < modLength; i++)
 {
  mods[i] *= 2;
  mods[i] %= first5239[i];
 }
}
void ProcessFile2(int *file, int fileLength)
{
 int primeLength = 7;
 int maxBits = PrimeLog(primeLength);
 int *temp = calloc(maxBits, sizeof(int));
 CopyArray(file, temp, 0, maxBits);
 int *mods= BinToModList(temp,maxBits,primeLength);
 for(int i = 0; i < maxBits; i++)
 {
  PrintArray(temp,maxBits-i);
  int *modsTrue= BinToModList(temp,maxBits-i,primeLength);
  PrintMods(modsTrue,primeLength);
  RemoveLastBit(modsTrue,primeLength, temp[maxBits-(i+1)]); //Avoid out of range erro
  PrintMods(modsTrue,primeLength);
  ReturnLastZero(modsTrue,primeLength);
  PrintMods(modsTrue,primeLength);
 }
 free(temp); 
}

Rule

1. Even values divide by 2 very well. Odd values gimme weird shit. ie (40 53) equals (20 53) then (11 13) equals (12 13)
2. Odd values add then divide by 2. eg (11 13 = 24/2 = 12 13 )

00101010001000100110011 (2)(3)(7)(17)(29)(31)(37)=00 10 101 00010 00100 11001