byte settings = 0b00000000;


void setBit(uint8_t &target, uint8_t x, bool set) {
  if (set)
    target |= (1 << x);
  else
    target &= ~(1 << x);

  target &= 0b11111111;
}

// -----------------------------------------------------

void shiftBit(uint8_t &x, uint8_t bit, bool dir=1) {
  if (dir) x = (x << bit); // left shift
  else     x = (x >> bit); // right shift
}

// -----------------------------------------------------

void clearBit(uint8_t &x, uint8_t bit) {
  x &= ~(1 << bit);
}

// -----------------------------------------------------

bool getSetting(int x) {
  return ((settings & (1 << x)) != 0);
}
// -----------------------------------------------------

void setSetting(int x, bool set) {
  if (set)
    settings |= (1 << x);
  else
    settings &= ~(1 << x);

  settings &= 0b1111;
}

// -----------------------------------------------------
  
void Send(byte x=0x00, byte addr=0x00, byte data=0x20) { 
  x &= 0b111111;
    
  if ( x & (1 << 0) ) return; //serial(ON);
  if ( x & (1 << 1) ) return; //spi_send( 0x20 | (addr & 0xF) );
  if ( x & (1 << 2) ) return; //spi_send( data ), delayUs(2);
  if ( x & (1 << 3) ) return; //serial(OFF);
  if ( x & (1 << 4) ) return; //Show();   
}

void setup() {
  Serial.begin(115200);
  byte mask = 0b11111111;
  byte a = 0b00010000; Serial.println(a & mask, BIN);

}

// -----------------------------------------------------

void loop() {}

/*
#define Prnt   Serial.print
#define Prntln Serial.println


void boolOpts() {
  uint8_t src = 0x6B; // DEC 107 | BIN 0b1101011
  bool bools[8] = {0,0,0,0,0,0,0,0};

  if (x&(1<<5)) Serial.println("8 SET!");
  for (int i=0; i<8; i++) 
    if ((x & (1 << i)) != 0) bools[i] = 1;
  for (int i=0; i<8; i++) Serial.print(i), Serial.print(" "), Serial.println(bools[i]);
}

void checkReg() {
  uint8_t x = 0b100100;
  //            543210
  bool bools[8] = {0,0,0,0,0,0,0,0};

  if (x&(1<<5)) Serial.println("8 SET!");
  for (int i=0; i<8; i++) 
    if ((x & (1 << i)) != 0) bools[i] = 1;
  for (int i=0; i<8; i++) Serial.print(i), Serial.print(" "), Serial.println(bools[i]);
}

uint8_t checkSet(uint8_t comp, uint8_t val) {
  uint8_t bitsSet[8];
  uint8_t count = 0;
  bool found = false;

  for (int i=0; i<8; i++)
    if ((comp  & (1 << i)) != 0)
      bitsSet[count++] = i;

  
  while (!found) {
      randomSeed(analogRead(A5));
      int n = random(0, count);
      if ( (val & (1 << bitsSet[n] )) == 0 ) {
        val |= (1 << bitsSet[n]);
        found = true; break;
      }   
  }

  return val;
}

void setBit(unsigned int &target, uint8_t x, bool set) {
  if (set)
    target |= (1 << x);
  else
    target &= ~(1 << x);

  target &= 0b0000111111111111;
}

void setup() {
  Serial.begin(9600);
  
  int mask = (1 << 5) - 1;
  byte result, sourceByte = 0x1F;

  checkReg();

  result = sourceByte & mask;

  Prnt("src:  "), Prntln(sourceByte, BIN);
  Prnt("res:  "), Prntln(result, BIN);

  result = sourceByte & 0b11110000; // isolate upper 4 bits
  Prnt("res1: "), Prntln(result, BIN);

  result = sourceByte & 0b1111; // isolate lower 4 bits
  Prnt("res2: "), Prntln(result, BIN);

  result = sourceByte & 0b1; // isolate lowest bit
  Prnt("res3: "), Prntln(result, BIN);

    //RndDraw();


  for (;;);
}

void loop() {
  delay(1);
}



void setup_old() {
  
  Serial.begin(9600);

  bool written[5] = {0,0,0,0,0};
  uint8_t write_count = 0;

  uint8_t inputs[5] = { 0x01,0x0F,0x80,0x15,0x40};
  uint8_t values[5] = { 0x00,0x00,0x00,0x00,0x00};

  while (write_count < 5) { 
    byte comp, value;
    int index = -1;
    

    while (index < 0) {
      rnd = random(0,5); randomSeed(analogRead(A5));
      if (!written[rnd]) index = rnd;
    }

    values[index] = checkSet(inputs[index], values[index]);
    Prnt(index),Prnt(" "), Prntln(values[index]);

    if (values[index] == inputs[index]) {
      written[index] = 1;
      write_count++;
    }
  }

  uint8_t value = 0b00000000; // 10
  uint8_t comp =  0b00010101; // 15

  while (value != comp) {
    value = checkSet(comp, value);
    Prnt("value: "), Prntln(value, BIN);
  }

  uint8_t value = 0b00000000; // 10
  uint8_t comp =  0b00010101; // 15

  for (int i=0; i<8; i++) {

    if ( (comp  & (1 << i)) != (value & (1 << i)) )
      value |= (1 << i);

    uint8_t mask1 = (comp  & (1 << i));
    uint8_t mask2 = (value & (1 << i));

    Serial.print(mask1); Serial.print(" "); Serial.print(mask2);
    Serial.println();
  }
  for (;;);

  bool bools[8] = {0,0,0,0,0,0,0,0};

  for (int i=0; i<8; i++) 
    if ((comp  & (1 << i)) != 0) bools[i] = 1;

  for (int i=0; i<8; i++) Serial.print(i), Serial.print(" "), Serial.println(bools[i]);
  
  
  for(;;);

  for (int i=0; i<8; i++) {
    
    uint8_t mask1 = (comp  & (1 << i));
    uint8_t mask2 = (value & (1 << i));

    Serial.print(mask1);

    if (mask1 && (mask1 != mask2))
      Serial.print(" NOT SET!");

    Serial.println();
    //Serial.print(mask1,BIN), Serial.print(" "), Serial.println(mask2,BIN);
    //if (mask1 != mask2)
    //uint8_t mask = 1 << i;
    //bool isBitSet = (value & mask) != 0;
    //Serial.print("bit "), Serial.print(i),Serial.print(": "), Serial.println(isBitSet);
  }
  
  bool match[8] = {0,0,0,0,0,0,0,0};
  //checkBit(value, 1);
  //for (int i=0; i<8; i++)  checkBit(value, i);

  for (;;);

  
  for (int i=0; i<8; i++) {
    mask = comp & i;

    bool matching = ((value << i) && mask);
    Serial.print("value: "), Serial.println(value,BIN);
    Serial.print("comp : "), Serial.println(comp,BIN);
    Serial.print("matching : "), Serial.println(matching,BIN);

    match[i] = (value & mask) != 0; // value and mask bits matches
    //if (match[i])

  }
  bool isFirstBitSet = (value & mask) != 0;

  // The binary representation of 10 is 0000 1010
  Serial.println(value,BIN);

  // Shifting the bit 1 to the left by 3 positions gives us 0000 1000
  Serial.println(mask,BIN);

  // The bitwise AND operation with 0000 1000 checks if the bit is set or not
  Serial.println(isFirstBitSet,BIN);
  
}
*/
/*
uint64_t packed = 0;
uint64_t unpacked = 0;

uint64_t packBytes(uint8_t *data) {
  packed = 0;
  for (int i = 4; i >= 0; i--) {
      packed <<= 8;
      packed += (uint64_t)data[i];
  }
  return packed;
}

char uint64_str[21];

char * uint64ToStr( const uint64_t num, char *str ) {
  uint8_t i = 0;
  uint64_t n = num;
  
  do i++; while ( n /= 10 );
  str[i] = '\0';
  n = num;
 
  do str[--i] = ( n % 10 ) + '0'; while ( n /= 10 );
  return str;
}


void ull2bytes() {
    uint8_t inputs[5] = { 0x01,0x0F,0x80,0x15,0x40};
  uint8_t bytes[5] = {0x00,0x00,0x00,0x00,0x00};

  
  packed = 0;

  for (int i = 4; i >= 0; i--) {
      packed <<= 8;
      packed += (uint64_t)inputs[i];
  }

  Serial.print("packed: "), Serial.println(uint64ToStr(packed, uint64_str));

  Prntln("packed: ");
  for (int i=32; i >=0; i--) {
    if ((packed  & (1 << i)) != 0) Prnt("1 "); else Prnt("0 ");
  }
  Prntln();

  unpacked = 0b00000000000000000000000000000000; 
  bool written = false;

  while (unpacked != packed) {
    for (int i=32; i >=0; i--) {
      if (((packed & (1 << i)) != 0) && ((unpacked  & (1 << i)) == 0)) {
        unpacked |= (1 << i); //unpacked |= (packed & (1 << i));
        break;
      }
    }
    Prntln();

    for (int i = 0; i < 5; i++) {
      bytes[i] = unpacked & 0xFF; // Extract least significant byte
      unpacked >>= 8;              // Shift to next byte
    }

    for (int i = 0; i<5; i++)
      Prnt(bytes[i], HEX), Prnt(" ");
    Prntln();
    delay(100);

  }
}
*/