#include <cstddef>
#include <cstdint>

struct Args0 {
  uint8_t *source;
  uint8_t *mask;
  uint8_t *destination;
  uint32_t offset;
  uint32_t length;
};

struct Args1 {
  uint8_t *source;
  size_t length;
  uint8_t *mask;
};

void* Mask(Args0 args0) {
  uint8_t *source = args0.source;
  uint8_t *mask = args0.mask;
  uint8_t *destination = args0.destination;
  uint32_t offset = args0.offset;
  uint32_t length = args0.length;

  destination += offset;
  uint32_t index = 0;

  //
  // Alignment preamble.
  //
  while (index < length && ((size_t)source % 8)) {
    *destination++ = *source++ ^ mask[index % 4];
    index++;
  }

  length -= index;
  if (!length)
    return NULL;

  //
  // Realign mask and convert to 64 bit.
  //
  uint8_t maskAlignedArray[8];

  for (uint8_t i = 0; i < 8; i++, index++) {
    maskAlignedArray[i] = mask[index % 4];
  }

  //
  // Apply 64 bit mask in 8 byte chunks.
  //
  uint32_t loop = length / 8;
  uint64_t *pMask8 = (uint64_t *)maskAlignedArray;

  while (loop--) {
    uint64_t *pFrom8 = (uint64_t *)source;
    uint64_t *pTo8 = (uint64_t *)destination;
    *pTo8 = *pFrom8 ^ *pMask8;
    source += 8;
    destination += 8;
  }

  //
  // Apply mask to remaining data.
  //
  uint8_t *pmaskAlignedArray = maskAlignedArray;

  length %= 8;
  while (length--) {
    *destination++ = *source++ ^ *pmaskAlignedArray++;
  }

  return NULL;
}

void* Unmask(Args1 args1) {
  uint8_t *source = args1.source;
  size_t length = args1.length;
  uint8_t *mask = args1.mask;

  uint32_t index = 0;

  //
  // Alignment preamble.
  //
  while (index < length && ((size_t)source % 8)) {
    *source++ ^= mask[index % 4];
    index++;
  }

  length -= index;
  if (!length)
    return NULL;

  //
  // Realign mask and convert to 64 bit.
  //
  uint8_t maskAlignedArray[8];

  for (uint8_t i = 0; i < 8; i++, index++) {
    maskAlignedArray[i] = mask[index % 4];
  }

  //
  // Apply 64 bit mask in 8 byte chunks.
  //
  uint32_t loop = length / 8;
  uint64_t *pMask8 = (uint64_t *)maskAlignedArray;

  while (loop--) {
    uint64_t *pSource8 = (uint64_t *)source;
    *pSource8 ^= *pMask8;
    source += 8;
  }

  //
  // Apply mask to remaining data.
  //
  uint8_t *pmaskAlignedArray = maskAlignedArray;

  length %= 8;
  while (length--) {
    *source++ ^= *pmaskAlignedArray++;
  }

  return NULL;
}

#include <cstddef>
#include <cstdint>

struct Args0 {
  uint8_t *source;
  uint8_t *mask;
  uint8_t *destination;
  uint32_t offset;
  uint32_t length;
};

struct Args1 {
  uint8_t *source;
  size_t length;
  uint8_t *mask;
};

void* Mask(Args0 args0) {
  uint8_t *source = args0.source;
  uint8_t *mask = args0.mask;
  uint8_t *destination = args0.destination;
  uint32_t offset = args0.offset;
  uint32_t length = args0.length;

  destination += offset;
  uint32_t index = 0;

  //
  // Alignment preamble.
  //
  while (index < length && ((size_t)source % 8)) {
    *destination++ = *source++ ^ mask[index % 4];
    index++;
  }

  length -= index;
  if (!length)
    return NULL;

  //
  // Realign mask and convert to 64 bit.
  //
  uint8_t maskAlignedArray[8];

  for (uint8_t i = 0; i < 8; i++, index++) {
    maskAlignedArray[i] = mask[index % 4];
  }

  //
  // Apply 64 bit mask in 8 byte chunks.
  //
  uint32_t loop = length / 8;
  uint64_t mask8 = ((uint64_t *)maskAlignedArray)[0];
  uint64_t *pFrom8 = (uint64_t *)source;
  uint64_t *pTo8 = (uint64_t *)destination;
  for (uint32_t i = 0; i < loop; i++) pTo8[i] = pFrom8[i] ^ mask8;
  source += 8 * loop;
  destination += 8 * loop;

  //
  // Apply mask to remaining data.
  //

  length %= 8;
  for (uint32_t i = 0; i < length; i++) {
    destination[i] = source[i] ^ maskAlignedArray[i];
  }

  return NULL;
}

void* Unmask(Args1 args1) {
  uint8_t *source = args1.source;
  uint8_t *mask = args1.mask;
  size_t length = args1.length;

  uint32_t index = 0;

  //
  // Alignment preamble.
  //
  while (index < length && ((size_t)source % 8)) {
    *source++ ^= mask[index % 4];
    index++;
  }

  length -= index;
  if (!length)
    return NULL;

  //
  // Realign mask and convert to 64 bit.
  //
  uint8_t maskAlignedArray[8];

  for (uint8_t i = 0; i < 8; i++, index++) {
    maskAlignedArray[i] = mask[index % 4];
  }

  //
  // Apply 64 bit mask in 8 byte chunks.
  //
  uint32_t loop = length / 8;
  uint64_t mask8 = ((uint64_t *)maskAlignedArray)[0];

  uint64_t *pSource8 = (uint64_t *)source;
  for (uint32_t i = 0; i < loop; i++) pSource8[i] ^= mask8;
  source += 8 * loop;

  //
  // Apply mask to remaining data.
  //

  length %= 8;
  for (uint32_t i = 0; i < length; i++) {
    source[i] ^= maskAlignedArray[i];
  }

  return NULL;
}