C / C++ / MFC

void Invert( unsigned char * p_pucData, unsigned long p_ulLen )
{
   __asm
   {
      // Save all registers.
      pusha

      // ecx will be our Counter.
      mov ecx, p_ulLen
      
      // ebx will be our pointer to the current dword or byte.
      mov ebx, p_pucData
      
      // main loop.
      head:
      
      // Check if we're done doing the dwords.
      cmp ecx, 4
      jle tailbytes
      
      // Bitwise NOT the dword pointed to by ebx.
      not dword ptr [ebx]
      
      // Subtract 4 bytes from our counter.
      sub ecx, 4
      
      // Check if we're done.
      cmp ecx, 0
      je end
      
      // Increment the data pointer by 4 bytes.
      add ebx, 4
      
      // Jump to the start of the main loop.
      jmp head
      
      // Leftover bytes loop.
      tailbytes:
      
      // Check if it's done.
      cmp ecx, 0
      je end
      
      // Bitwise NOT the current byte.
      not byte ptr [ebx]
      
      // Increment the data pointer by 1 byte.
      add ebx, 1
      
      // Subtract 1 byte from the counter.
      sub ecx, 1
      
      // Jump to the start of the loop.
      jmp tailbytes

      end:
      
      // Restore all registers.
      popa
   }
}

int z;
BYTE *pb = pBuf;

// handle non-aligned lead bytes
UINT32 uLeadUp = (DWORD)pBuf & 0x03;
for (z=0;z < uLeadUp;z++)
{
   *pb = ~(*pb);pb++;
}

uLen-=uLeadUp;

// handle as many aligned dwords as we can
UINT32 dwords = uLen / 4;
UINT32 leftovers = uLen % 4;

DWORD *p = (DWORD*)pb;

for (z=0;z < dwords;z++)
{
   *p = ~(*p);
   p++;
}

pb+=4; // skip that last DWORD

// finish the tail
for (z=0;z < leftovers;z++)
{
   pb[z] = ~pb[z];
}