byte char_bit = 8;
byte CHAR_BIT = char_bit;

// macro uses 30+ instructions and two branches

#define reverse_1byte(b)    ( ((uint8_t)b & 0b00000001) ? 0b10000000 : 0 ) | \
  ( ((uint8_t)b & 0b00000010) ? 0b01000000 : 0 ) | \
  ( ((uint8_t)b & 0b00000100) ? 0b00100000 : 0 ) | \
  ( ((uint8_t)b & 0b00001000) ? 0b00010000 : 0 ) | \
  ( ((uint8_t)b & 0b00010000) ? 0b00001000 : 0 ) | \
  ( ((uint8_t)b & 0b00100000) ? 0b00000100 : 0 ) | \
  ( ((uint8_t)b & 0b01000000) ? 0b00000010 : 0 ) | \
  ( ((uint8_t)b & 0b10000000) ? 0b00000001 : 0 )


void setup() {

  Serial.begin(115200);
  unsigned char startVal = 0x3A;
  unsigned char argument = startVal;
  //
  //--------------------
  // as function makes compiler include it

  for (byte i = 0; i < 254; i++) {
    argument = reverse(i);
    Serial.print(i, HEX);
    Serial.print(" bits reversed is: ");
    Serial.println(argument, HEX);
  }

  /*
    for (byte i = 0x0; i < 0xff; i++) {
      argument = reverse_byte(i); // via lookup table
      Serial.print(i, HEX);
      Serial.print(" bits reversed is: ");
      Serial.println(argument, HEX);
    }
  */
  //------------------------------
  /*
    for (byte i = 0x61; i < 0x67; i++) {
     unsigned char arg2;
     arg2 = obvious(i); // algorithm from bit twiddling hacks
     Serial.print(i, HEX);
     Serial.print(" bits reversed is: ");
     Serial.println(arg2, HEX);
     }
  */

  //------------------------------
  // revrese by rotation
  // https://stackoverflow.com/questions/2602823/in-c-c-whats-the-simplest-way-to-reverse-the-order-of-bits-in-a-byte


  /*
    for (byte i = 0x0; i < 0xff; i++) {
      unsigned char arg2;
      arg2 = reverse01(i); //
      Serial.print(i, HEX);
      Serial.print(" bits reversed is: ");
      Serial.println(arg2, HEX);
    }
  */

  /*
    for (byte i = 0x0; i < 0xff; i++) {
      unsigned char arg2;
      arg2 = reverse_1byte(i); //
      Serial.print(i, HEX);
      Serial.print(" bits reversed is: ");
      Serial.println(arg2, HEX);
    }
  */
  // for (byte i = 0x0; i < 0xff; i++) {
  //   unsigned char arg2;
  //   arg2 = reverse02(i); //
  //   Serial.print(i, HEX);
  //   Serial.print(" bits reversed is: ");
  //   Serial.println(arg2, HEX);
  // }

  //
  // Insert bits uses only seventeen instructions and does not
  // require any branching or function call overhead.
  //
  
    for (byte i = 0x0; i < 0xff; i++) {
    unsigned char arg2;
    arg2 = __builtin_avr_insert_bits (0x01234567, i, 0);
    Serial.print(i, HEX);
    Serial.print(" bits reversed is: ");
    Serial.println(arg2, HEX);
    }
  
  /*
    for (byte i = 0x0; i < 0xff; i++) {
      unsigned char arg2;
      arg2 = reverse_bits(i);
      Serial.print(i, HEX);
      Serial.print(" bits reversed is: ");
      Serial.println(arg2, HEX);
    }
  */
  /*
  for (uint16_t i = 0x0; i < 0xffff; i++) {
    uint16_t arg2 = i;
    arg2 = reverse_sixteen(arg2);
    Serial.print(i, HEX);
    Serial.print(" bits reversed is: ");
    Serial.println(arg2, HEX);
  }
*/
}

void loop() {}
//###########################################################
//###########################################################
//#                       END OF LOOP                       #
//###########################################################
//###########################################################

// reverse the bit order of bits with built in function
//__builtin_avr_insert_bits (0x01234567, bits, 0);

uint16_t reverse_sixteen(uint16_t argument) {
  uint8_t lowEight, hiEight;
  uint16_t result = 0;
  lowEight = argument & 0xff;
  hiEight = argument >> 8;
  hiEight = reverse01(hiEight);
  lowEight = reverse01(lowEight);
  result |= lowEight << 8;
  result |= hiEight;
  return result;
}


unsigned char reverse02(unsigned char rv)
// can't make this one work either hdp 1/15/22
{
  unsigned char tmp = 0;

  tmp = ((rv & 0x01) << 7);
  tmp = tmp | ((rv & 0x02) << 6);
  tmp = tmp | ((rv & 0x04) << 5);
  tmp = tmp | ((rv & 0x08) << 4);
  tmp = tmp | ((rv & 0x10) << 3);
  tmp = tmp | ((rv & 0x20) << 2);
  tmp = tmp | ((rv & 0x40) << 1);
  tmp = tmp | ((rv & 0x80)) ;

  return tmp;
}



//There is no rotation operator in C, but if you write:
// can't make it work right hdp 1/15/22
// unsigned char rotl(unsigned char c)
// {
//     return (c << 1) | (c >> 7);
// }

unsigned char rotl(unsigned char c)
{
  unsigned char tmp = 0;
  tmp = (c & 0x80) >> 1;
  c = c << 1 ;
  tmp = (tmp | (c & 0x80)) >> 1;
  c = c << 1 ;
  tmp = (tmp | (c & 0x80)) >> 1;
  c = c << 1 ;
  tmp = (tmp | (c & 0x80)) >> 1;
  c = c << 1 ;
  tmp = (tmp | (c & 0x80)) >> 1;
  c = c << 1 ;
  tmp = (tmp | (c & 0x80)) >> 1;
  c = c << 1 ;
  tmp = (tmp | (c & 0x80)) >> 1;
  c = c << 1 ;
  tmp = (tmp | (c & 0x80)) >> 1;

  return tmp;
}

//----------------------------------------------------------------
// it's simple and fast - but it uses branching, which adds cycles
unsigned char reverse01(unsigned char rv)
{
  unsigned char tmp = 0;
  if ( rv & 0x01 ) tmp = 0x80;
  if ( rv & 0x02 ) tmp |= 0x40;
  if ( rv & 0x04 ) tmp |= 0x20;
  if ( rv & 0x08 ) tmp |= 0x10;
  if ( rv & 0x10 ) tmp |= 0x08;
  if ( rv & 0x20 ) tmp |= 0x04;
  if ( rv & 0x40 ) tmp |= 0x02;
  if ( rv & 0x80 ) tmp |= 0x01;
  return tmp;
}

// with two lines
// https://stackoverflow.com/questions/2602823/in-c-c-whats-the-simplest-way-to-reverse-the-order-of-bits-in-a-byte
/*
  for (i = 0; i < 8; i++)
  reversed |= ((original >> i) & 0b1) << (7 - i);

  // or in case you have issues with the "0b1" part:

  for (i = 0; i < 8; i++)
  reversed |= ((original >> i) & 1) << (7 - i);

*/
//-----------------------------------------
// reverse by rotation
unsigned char reverse_bits(unsigned char b)
{
  unsigned char   r = 0;
  unsigned        byte_len = 8;

  while (byte_len--) {
    r = (r << 1) | (b & 1);
    b >>= 1;
  }
  return r;
}

// An inline assembler solution - x86
// on the same page

// [C++ Only] Reverse Any Unsigned (Template)
// https://stackoverflow.com/questions/2602823/in-c-c-whats-the-simplest-way-to-reverse-the-order-of-bits-in-a-byte
/*
  template <class T> // untested
  T reverse_bits(T n) {
  short bits = sizeof(n) * 8;
  T mask = ~T(0); // equivalent to uint32_t mask = 0b11111111111111111111111111111111;

  while (bits >>= 1) {
    mask ^= mask << (bits); // will convert mask to 0b00000000000000001111111111111111;
    n = (n & ~mask) >> bits | (n & mask) << bits; // divide and conquer
  }

  return n;
  }

  template <typename T> // untested
  T reverse_T(T n, size_t b = sizeof(T) * CHAR_BIT)
  {
  //assert(b <= std::numeric_limits<T>::digits);

  T rv = 0;

  for (size_t i = 0; i < b; ++i, n >>= 1) {
    rv = (rv << 1) | (n & 0x01);
  }

  return rv;
  }
*/
//Reverse bits the obvious way - bit twiddling hacks

unsigned char  obvious(unsigned char v) { // input bits to be reversed
  unsigned char r = v; // r will be reversed bits of v; first get LSB of v
  int s = sizeof(v) * char_bit - 1; // extra shift needed at end

  for (v >>= 1; v; v >>= 1)
  {
    r <<= 1;
    r |= v & 1;
    s--;
  }
  r <<= s; // shift when v's highest bits are zero
  return r;
}

// function to reverse bits in a byte - sswap nybbles, then bit pairs, then bits
unsigned char reverse(unsigned char b) {
  b = (b & 0xF0) >> 4 | (b & 0x0F) << 4;
  b = (b & 0xCC) >> 2 | (b & 0x33) << 2;
  b = (b & 0xAA) >> 1 | (b & 0x55) << 1;
  return b;
}

unsigned char reverse_byte(unsigned char x)
{
  static const unsigned char table[] = {
    0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
    0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
    0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
    0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
    0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,
    0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
    0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,
    0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
    0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
    0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
    0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
    0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
    0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,
    0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
    0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
    0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
    0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,
    0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
    0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,
    0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
    0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
    0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
    0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,
    0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
    0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,
    0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
    0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
    0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
    0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,
    0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
    0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
    0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff,
  };
  return table[x];
}