public static void Execute(NativeArray <byte> outputData, int typeSize, NativeArray <byte> componentByteArray, NativeArray <PersistenceState> persistenceStateArray)
        {
            const int amountFound      = 1;
            int       totalElementSize = typeSize + PersistenceMetaData.SizeOfStruct;

            for (int i = 0; i < persistenceStateArray.Length; i++)
            {
                PersistenceState persistenceState = persistenceStateArray[i];

#if ENABLE_UNITY_COLLECTIONS_CHECKS
                if (persistenceState.ArrayIndex * totalElementSize >= outputData.Length)
                {
                    throw new IndexOutOfRangeException("CopyComponentDataToByteArray:: persistenceState.ArrayIndex seems to be out of range. Or the totalElementSize is wrong.");
                }
#endif

                PersistenceMetaData *outputMetaDataBytePtr = (PersistenceMetaData *)((byte *)outputData.GetUnsafePtr() + (persistenceState.ArrayIndex * totalElementSize));
                void *outputDataBytePtr = outputMetaDataBytePtr + 1;
                void *compDataBytePtr   = (byte *)componentByteArray.GetUnsafeReadOnlyPtr() + (i * typeSize);

                // Diff
                int diff = outputMetaDataBytePtr->AmountFound - amountFound;
                diff |= UnsafeUtility.MemCmp(outputDataBytePtr, compDataBytePtr, typeSize);

                // Write Meta Data
                *outputMetaDataBytePtr = new PersistenceMetaData(diff, amountFound); // 1 branch in this constructor

                // Write Data
                UnsafeUtility.MemCpy(outputDataBytePtr, compDataBytePtr, typeSize);
            }
        }
        public static void Execute(NativeArray <byte> outputData, int maxElements, UnsafeUntypedBufferAccessor untypedBufferAccessor,
                                   NativeArray <PersistenceState> persistenceStateArray)
        {
            int elementSize   = untypedBufferAccessor.ElementSize;
            int sizePerEntity = elementSize * maxElements + PersistenceMetaData.SizeOfStruct;

            for (int i = 0; i < persistenceStateArray.Length; i++)
            {
                PersistenceState persistenceState = persistenceStateArray[i];

#if ENABLE_UNITY_COLLECTIONS_CHECKS
                if (persistenceState.ArrayIndex >= outputData.Length / sizePerEntity)
                {
                    throw new IndexOutOfRangeException("CopyBufferElementsToByteArray:: persistenceState.ArrayIndex seems to be out of range. Or the sizePerEntity is wrong.");
                }
#endif

                void *bufferDataPtr = untypedBufferAccessor.GetUnsafeReadOnlyPtrAndLength(i, out int length);;

                PersistenceMetaData *outputMetaBytePtr = (PersistenceMetaData *)((byte *)outputData.GetUnsafePtr() + persistenceState.ArrayIndex * sizePerEntity);
                void *outputDataBytePtr = outputMetaBytePtr + 1;
                int   amountToCopy      = math.clamp(length, 0, maxElements);

                // Diff
                int diff = outputMetaBytePtr->AmountFound - amountToCopy;
                diff |= UnsafeUtility.MemCmp(outputDataBytePtr, bufferDataPtr, amountToCopy * elementSize);

                // Write Meta Data
                *outputMetaBytePtr = new PersistenceMetaData(diff, (ushort)amountToCopy); // 1 branch in this constructor

                // Write Data
                UnsafeUtility.MemCpy(outputDataBytePtr, bufferDataPtr, elementSize * amountToCopy);
            }
        }