//+------------------------------------------------------------------+
//|                                                        UEPar.mq5 |
//|                                  Copyright 2026, Niquel Mendoza. |
//|                                            https://www.mql5.com/ |
//+------------------------------------------------------------------+
#property copyright "Copyright 2026, Niquel Mendoza."
#property link      "https://www.mql5.com/"
#property version   "1.00"
#property strict

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
#define TSNTABLES_SWAR_MASK_BACK_SLASH  (0x5C5C5C5C5C5C5C5C)
#define TSNTABLES_SWAR_MASK_COMILLA     (0x2222222222222222)
#define TSNTABLES_SWAR_LO 0x0101010101010101
#define TSNTABLES_SWAR_HI 0x8080808080808080
#define TSNTABLES_SWAR_HAS(mask) ((mask - TSNTABLES_SWAR_LO) & ~mask & TSNTABLES_SWAR_HI)

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
template <typename T>
string ToBits(T v)
 {
  string str = "";
  for(int i = (sizeof(T) << 3) - 1 ; i >= 0; i--)
   {
    str += string(uchar((v & (1ULL << i)) == 0 ? 0 : 1));
   }
  return str;
 }
//+------------------------------------------------------------------+
// 110
// 010


//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
 {
  union U
   {
    ulong v;
    uchar data[8];
   };

  U va;
  va.data[0] = 'a';
  va.data[1] = 'b';
  va.data[2] = '\\';
  va.data[3] = '\\';
  va.data[4] = 'e';
  va.data[5] = 'f';
  va.data[6] = 'g';
  va.data[7] = '\\';
// 8=\
// 9=\


  ulong str = va.v;

//---
// 1100 0000 10
// 1100 0000 1100 0000
// 0000 0000

//---
  ulong x_bs = str ^ TSNTABLES_SWAR_MASK_BACK_SLASH;
  ulong x_qt = str ^ TSNTABLES_SWAR_MASK_COMILLA;
  ulong has_bs = TSNTABLES_SWAR_HAS(x_bs);
  ulong has_qt = TSNTABLES_SWAR_HAS(x_qt);


//--- Metodo base
  ulong bits = has_bs >> 7;
  const ulong magic = 0x0102040810204080;
  const uchar compacted_bs = uchar(((bits * magic) >> 56) & 0xFF);
  Print(ToBits(compacted_bs));
  const uchar even_mask = B'01010101';
  uchar starts = compacted_bs & ~(compacted_bs << 1);
  Print("starts");
  Print(ToBits(starts));

  uchar starts_par   = starts & even_mask;
  uchar starts_impar = starts & ~even_mask;



  Print("starts f");
  Print(ToBits(starts_par));
  Print(ToBits(starts_impar));
  uchar sum_par   = compacted_bs + starts_par;
  const ushort sum_impar_wide = (ushort)compacted_bs + ushort(starts_impar);
  Print("sum f");

  Print(ToBits(sum_par));
  Print(ToBits(sum_impar_wide));


  uchar end_par   = sum_par & ~compacted_bs;
  uchar end_impar = uchar(sum_impar_wide & 0xff)   & ~compacted_bs;
  Print(ToBits(end_par));
  Print(ToBits(end_impar));

  uchar end_final = (end_impar & even_mask) | (end_par & ~even_mask);
  Print(ToBits(end_final));

  bits = has_qt >> 7;
  const uchar compacted_qt = uchar(((bits * magic) >> 56) & 0xFF);
  uchar Q_real = compacted_qt & ~end_final;
  Print(ToBits(Q_real));
 }
// 1001
// 0110
// 1000 0000 0000 1000
//
//
//

//+------------------------------------------------------------------+
// 11011100     Base
// 10111000     << 1 para deteerminar el fin de cada racha y el bit niical de cada racha queda en 0 (previo a una rahca hay un 0)
// 01000111     ~  Ahora volteas el reusltoad  y te da 0 donde habai racha y 1 en el inicio y donde habia 0      
//---
// 01000111 & // para limpiar
// 11011100
// 01000100
//---
// Luego se hace and con mascaras con pares.. la idea es procesar por 
// separado las maracas de rachas pares e impares.
//--- Starts par por ejemplo..
// 01000100  (se queda tal cual)
// 11011100 + // se suma con los starts esto hace que se valle prestando 1 (1+1 inicial) y al final de la racha par deje un bit prendido
//[1]00100000
// ...