public static void Execute(NativeArray <byte> inputData, int maxElements, UnsafeUntypedBufferAccessor untypedBufferAccessor,
                                   NativeArray <PersistenceState> persistenceStateArray)
        {
            Debug.Assert(maxElements < PersistenceMetaData.MaxValueForAmount);
            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 >= inputData.Length / sizePerEntity)
                {
                    throw new IndexOutOfRangeException("CopyByteArrayToBufferElements:: persistenceState.ArrayIndex seems to be out of range. Or the sizePerEntity is wrong.");
                }
#endif

                PersistenceMetaData *inputMetaDataPtr = (PersistenceMetaData *)((byte *)inputData.GetUnsafeReadOnlyPtr() + persistenceState.ArrayIndex * sizePerEntity);
                void *inputDataBytePtr = inputMetaDataPtr + 1; // + 1 because it's a PersistenceMetaData pointer

                // Resize
                int amountToCopy = inputMetaDataPtr->AmountFound;
                untypedBufferAccessor.ResizeUninitialized(i, amountToCopy);

                // Get (Possibly modified because of resize) ptr to buffer data
                void *bufferDataPtr = untypedBufferAccessor.GetUnsafePtrAndLength(i, out int length);
                Debug.Assert(length == amountToCopy);

                // Write Data
                UnsafeUtility.MemCpy(bufferDataPtr, inputDataBytePtr, elementSize * amountToCopy);
            }
        }
        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);
            }
        }