Feature: Support writing in to pre-existing dat files

[helpful-fox-senko-san]

Required for full support for Traditional Chinese FFXIV ( TexTools/FFXIV_TexTools_UI#357 )

Currently modded game files are only written out to brand new dat files (i.e. 040000.win32.dat7) . This was always possible in the past, but the recent Traditional Chinese version of FFXIV has allocated all 8 possible dat files from 040000.win32.dat0 to 040000.win32.dat7

The maximum size of a dat file is 32GB.

Current plan is to implement a mechanism where a dat file can be chosen to write in to, we make it sparse, and then mod files are written at some deeper offset in to the file.

• A fixed 16GB offset for mods was proposed, however this would cause significant disk space wastage in the cases where the sparseness is lost. This could be caused by something like copying the files across drives/network, zipping and unzipping, etc.
• Personally I think an offset of 4GB, on the highest numbered dat file under 4GB, might be preferable?
• There's not much worry about Linux, as I think files generally will be sparse by default anyway

Generated dat files are currently marked with a magic number, so we know when they are safe to write in to or delete. It is still possible to mark the vanilla game files with a unique mark -- I believe that it is relatively safe when it comes to patching -- however it possible for an update to replace the dat file header data.

Instead of only marking the dat file header, I propose writing a magic signature to the start of the modded data offset, i.e., 4GB in to the file, followed by some metadata (such as the original file length).

All of the other worries come from what will happen if someone patches the game without doing a "Start Over" to remove all of their mods, while also being unable to query back the sparse ranges of the file...

---

We need to remember the original file size, so the dat file can be reverted back to its original size for "Start Over". Ideally we want to be able to do this without a risk of corrupting the dat file by over-truncating it if it were patched to a larger size.

• It is possible to query back the sparse range, however it is not great to rely on the file remaining sparse (it probably also doesn't work under WINE)
• Scanning for a very long sequence of zeroes doesn't seem reliable as a fallback, either.

I propose writing a magic signature not only 4GB in to the file, but also a large portion beginning what was previously the end of the file as well, to act as a canary to detect if a patch added data.

There is slim chance that a patch writes around these magic sections, and then of course we will have a corrupted dat file as well. Again, though, this can still be detected, as long as the sparse ranges in the file can be queried back.

Here's a pretty picture of how the dat files would look vanilla vs modded

---

Finally any advice about deleting dat7 needs to be purged from existence. :)

[helpful-fox-senko-san]

Pseudo-code for how to deal with partially modded files

// TexTools marks dat files it created at offset 0x200
// There is an existing "ModifiedPartial" flag, but it gets treated the same as "ModifiedFull"
// To avoid indicating that a file is safe to be deleted (or written to below 4GB), mark the header at 0x210 instead
// Specifically: 0x210: 0x67696769
//               0x214: MOD_DATA_OFFSET / 8
// Older versions of TT will just treat this file as vanilla
long DAT_PARTIALLY_MODDED_OFFSET = 0x210;
uint MAGIC_PARTIALLY_MODDED = 0x67696769;

// Only consider dat files smaller than 2GB for modding
// This could be increased up to 4GB - 1MB, but having it be this small guarantees a larger buffer to catch patch writes
long MOD_ELIGIBLE_SIZE = 0x8000000; // 2GB

// The offset we will attempt to write the MAGIC69 section
// Mod data allocation actually begins at 4GB + 1MB
long MOD_DATA_OFFSET = 0x10000000; // 4GB

// The minimum offset we'll accept (This could be set lower than MOD_ELIGIBLE_SIZE)
long MIN_MOD_DATA_OFFSET = 0x8000000; // 2GB

// Size of the MAGIC67 and MAGIC69 sections used as canaries to detect file patching
// (However, the MAGIC69 section has its first 128 bytes reserved as a header)
long MAGIC_67_LENGTH = 0x100000;      // 1MB
long MAGIC_69_LENGTH = 0x100000;      // 1MB

enum CheckDatFileResult
{
	// The file is not eligible for modding (dat0 or too large in size already)
	NotEligible,
	// The file is eligible for modding and not already modded
	IsModdable,
	// The file contains modded data and passed all verification
	IsModded
};

// If the result is IsModded or IsModdable, we also return the mod data offset we'd like to use
// This is variable because we might want to pick a location other than 4GB in the future
(CheckDatFileResult Result, ulong ModDataOffset) CheckPartiallyModdedDatFile(File datFile)
{
	// A file less than 2GB + 1MB is definitely not modded
	// This will be true every file that currently exists in the vanilla game, except dat0 files
	// (but we will never consider dat0 files for writing, anyway)
	bool fileIsLarge = datFile.Length >= MIN_MOD_DATA_OFFSET + MAGIC_69_LENGTH;
	if (!fileIsLarge)
		return (CheckDatFileResult.IsModdable, MOD_DATA_OFFSET);

	// The mod data offset we read from the file
	ulong modDataOffset = 0;

	// A fast check for if a file is potentially modded
	// But it isn't a guarantee, as the header could have been overwritten by the patcher
	bool hasHeader = false;
	datFile.Position = DAT_PARTIALLY_MODDED_OFFSET;
	if (datFile.ReadUInt() == MAGIC_PARTIALLY_MODDED)
	{
		// Extract the mod data offset we should have written in to the dat header
		modDataOffset = (ulong)datFile.ReadUInt() * 8L;
		hasHeader = true;
		// Only accept a mod data offset that is greater than 2GB
		if (modDataOffset < MIN_MOD_DATA_OFFSET)
			modDataOffset = 0;
	}

	// If we didn't find an offset, the header could have just been overwritten!
	// Do some extra, quick checks for a modded data signature
	if (modDataOffset == 0)
	{
		// Check some offsets where we might expect to find our MAGIC69 signature written (2GB, 4GB, 8GB or 16GB)
		for (ulong eligibleOffset in [0x8000_0000, 0x1_0000_0000, 0x2_0000_0000, 0x4_0000_0000])
		{
			datFile.Position = eligibleOffset;
			var magic69Check = datFile.ReadBytes(64);
			bool magic69CheckFound = magic69Check.Length > 0 && magic69Check.All(b => b == 0x69);
			if (magic69CheckFound)
			{
				// We will assume that the file was modded
				// We don't immediately restore the header -- the dat writer can restore it instead
				modDataOffset = eligibleOffset;
				break;
			}
		}
	}

	// We didn't find any hint of the file being modded
	if (modDataOffset == 0)
	{
		// Do one final check if the file is eligible to be modded
		fileIsLarge = datFile.Length >= MOD_ELIGIBLE_SIZE;
		if (!fileIsLarge)
			return (CheckDatFileResult.IsModdable, MOD_DATA_OFFSET);

		// Potential failure: We had the magic value in the dat header, but the modded data offset was not valid
		//                    ... and we also failed to detect another plausible offset which is not destroyed
		//                    This is a very specific kind of corruption that would be unlikely to occur
		if (hasHeader)
			UnmarkPartiallyModdedDatFile(datFile);

		return (CheckDatFileResult.NotEligible, 0);
	}

	// Extract and check the MAGIC69 area
	// (The custom header embedded inside is not checked)
	datFile.Position = modDataOffset;
	var magic69Small = datFile.ReadBytes(64);
	datFile.Position = modDataOffset + 128;
	var magic69Large = datFile.ReadBytes(MAGIC_69_LENGTH - 128);
	bool magic69Intact = magic69Small.Length > 0 && magic69Small.All(b => b == 0x69)
	                     && magic69Small.Length > 0 && magic69Small.All(b => b == 0x69);

	// Failure: The MAGIC69 section is not in tact
	//          This implies that the file was patched *and* grew beyond 4GB
	if (!magic69Intact)
	{
		// We do NOT have information to safely shrink the file
		// However, if we were informed by the header that this file was modded, remove that data at least
		if (hasHeader)
			UnmarkPartiallyModdedDatFile(datFile);
		return (CheckDatFileResult.NotEligible, 0);
	}

	// We store the original file length in a custom header 64 bytes in to the MAGIC69 section
	datFile.Position = modDataOffset + 64;
	long originalFileLength = (long)datFile.ReadUInt() * 8L;
	// Failure: The embedded original file length is not valid
	//          This is a very specific kind of corruption that would be unlikely to occur
	if (originalFileLength < 0 || originalFileLength >= modDataOffset - MAGIC_67_LENGTH)
	{
		if (hasHeader)
			UnmarkPartiallyModdedDatFile(datFile);
		return (CheckDatFileResult.NotEligible, 0);
	}

	datFile.Position = originalFileLength;
	var magic67 = datFile.ReadBytes(originalFileLength, MAGIC_67_LENGTH);
	bool magic67Intact = magic67.Length > 0 && magic67.All(b => b == 0x67);
	// Failure: The MAGIC67 section is not in tact
	//          This implies the game was patched and the file grew a litle bit
	//          At this point we've confirmed the file was definitely modded, so we'll try to shrink the file
	if (!magic67Intact)
	{
		if (hasHeader)
			UnmarkPartiallyModdedDatFile(datFile);
		ShrinkPartiallyModdedDatFile(datFile, 0, modDataOffset);
		// After shrinking, check if the file is eligible to be modded again...
		// (at this point, the user probably has corrupted indexes anyway and needs to fix that)
		fileIsLarge = datFile.Length >= MIN_MOD_DATA_OFFSET + MAGIC_69_LENGTH;
		if (fileIsLarge)
			return (CheckDatFileResult.NotEligible, 0);
		else
			return (CheckDatFileResult.IsModdable, MOD_DATA_OFFSET);
	}

	// All checks completed: The dat file is modded.
	return (CheckDatFileResult.IsModded, modDataOffset);
}

// Recovery #1: Clear the "partially modded" indication from the header
void UnmarkPartiallyModdedDatFile(File datFile)
{
	datFile.Position = DAT_PARTIALLY_MODDED_OFFSET;
	datFile.WriteUInt(0);
	datFile.WriteUInt(4, 0);
}

// Recovery #2: Shrink a partially modded dat file where the MAGIC67 region was destroyed, but the MAGIC69 region is in tact
void ShrinkPartiallyModdedDatFile(File datFile, ulong originalFileLength, ulong modDataOffset)
{
	bool isSparse = IsFileSparse(datFile);

	// We didn't find a valid original file length
	// Most likely, the MAGIC67 section was clobbered by the patcher
	// Probe for an appropriate size to shrink to instead
	if (originalFileLength == 0)
	{
		if (isSparse)
		{
			// Find a region that ends at the beginning of the MAGIC69 section
			// The patcher will have written through the MAGIC67 section and in to the sparse region up to a certain point
			// The maximum distance in to the file written can in theory be queried back
			for (auto region : GetSparseRegionsForFile(file))
			{
				isSparse = true;
				// If there is a region that ends immediately before the MAGIC69 section, we found what we needed
				if ((region.Offset + region.Length) == modDataOffset)
				{
					originalFileLength = region.Offset;
					break;
				}
			}
		}
		else
		{
			// We don't know the original file length anymore, and the file is no longer sparse for some reason
			// All we can do now is keep reading backwards from the MAGIC69 section for as long as we see zeroes
			// This won't shrink the file back down to its true original size, but its better than doing nothing
			// TODO: Optimize this part as it will be very slow
			ulong ZeroCheckLength = 4 * 1024 * 1024; // Seek backwards 4MB at a time...
			for (ulong checkOffset = modDataOffset - ZeroCheckLength; checkOffset > 0; checkOffset -= ZeroCheckLength)
			{
				datFile.Position = checkOffset;
				var zeroChunk = datFile.ReadBytes(checkOffset, ZeroCheckLength);
				if (zeroChunk.Any(c => c != 0))
					break;
				originalFileLength = checkOffset;
			}
		}
	}

	// Shrink the file back down to its original file length (or our estimate)
	if (originalFileLength != 0)
	{
		datFile.Length = originalFileLength;
		MakeFileNotSparse(datFile);
	}
}

void CreatePartiallyModdedDatFile(File datFile, bool clearHeader, ulong modDataOffset)
{
	// If for some ungodly reason the dat file size is not divisible by 128, just pad it out
	datFile.Position = datFile.Length;
	while (datFile.Position % 128 != 0)
	{
		datFile.WriteByte(0);
		return false;
	}

	ulong originalFileLength = datFile.Length;

	var magic67 = new byte[MAGIC_67_LENGTH];
	Array.Fill(magic67, 0x67);

	var magic69 = new byte[MAGIC_69_LENGTH];
	Array.Fill(magic69, 0x69, 128, MAGIC_69_LENGTH - 128);

	// Fill out the header portion of the MAGIC69 section
	{
		using var ms = new MemoryStream(magic69, 64, 64);
		using var br = new BinaryWriter(ms);
		br.WriteUInt((uint)(originalFileLength / 8));
		for (int i = 0; i < 15; ++i)
			mr.WriteUInt(0);
	}

	MakeFileSparse(datFile);

	// Write the MAGIC67 section immediately after the original file data
	datFile.WriteBytes(magic67);

	// Fill the gap between MAGIC67 and MAGIC69 with zeroes
	ZeroSparseFileRange(datFile, zeroRangeBegin: originalFileLength + MAGIC_67_LENGTH, zeroRangeEnd: modDataOffset);

	// Write the MAGIC69 section at the mod data offset
	datFile.Position = modDataOffset;
	datFile.WriteBytes(magic69);

	// Finally, write a marker in to the header of the dat file to mark it as partially modded
	datFile.Position = DAT_PARTIALLY_MODDED_OFFSET;
	datFile.WriteUInt(DAT_PARTIALLY_MODDED_OFFSET, MAGIC_PARTIALLY_MODDED);
	datFile.WriteUInt(DAT_PARTIALLY_MODDED_OFFSET, (uint)(modDataOffset / 8));
}

Behavior w.r.t the rest of the system:

• If all 8 dat files are allocated and not fully modded, CheckPartiallyModdedDatFile() will be called on dat1 through dat7 to find the best eligible file to become the write target. The priority for write targets will naturally will become:
  • Any fully modded dat file
  • Creating a new fully modded dat file if possible
  • (new) Any partially modded dat file
  • (new) The highest numbered dat file which is eligible to be converted in to a partially modded file
• If the write target is going to be a partially modded file, the allocated data offsets for mod files will start at 4GB instead of 0.
• Instead of writing the value 1337 to 0x200 in the dat file header, it writes 0x67696769 to 0x210, and then 0x20000000 (4GB as an offset8x) to 0x214

The MAGIC67 and MAGIC69 canary sections are solid chunks of repeating values, except for the byte range 64 ~ 128 inside of the MAGIC69 section which looks like this in a hex dump:

100000000  69 69 69 69 69 69 69 69  69 69 69 69 69 69 69 69  |iiiiiiiiiiiiiiii|
100000010  69 69 69 69 69 69 69 69  69 69 69 69 69 69 69 69  |iiiiiiiiiiiiiiii|
100000020  69 69 69 69 69 69 69 69  69 69 69 69 69 69 69 69  |iiiiiiiiiiiiiiii|
100000030  69 69 69 69 69 69 69 69  69 69 69 69 69 69 69 69  |iiiiiiiiiiiiiiii|
100000040  78 56 34 12 00 00 00 00  00 00 00 00 00 00 00 00  |xV4.............|
100000050  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
100000060  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
100000070  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
100000080  69 69 69 69 69 69 69 69  69 69 69 69 69 69 69 69  |iiiiiiiiiiiiiiii|
...

In this example, 0x12345678 is the offset8x of the original file length, a.k.a. it is the file offset we expect to find the MAGIC67 section (0x12345678 × 8 = 0x91A2B3C0):

 91A2B3B0   ((the last sixteen bytes of legitimate dat file data))
 91A2B3C0  67 67 67 67 67 67 67 67  67 67 67 67 67 67 67 67  |gggggggggggggggg|
 91A2B3D0  67 67 67 67 67 67 67 67  67 67 67 67 67 67 67 67  |gggggggggggggggg|
...
 91B2B3B0  67 67 67 67 67 67 67 67  67 67 67 67 67 67 67 67  |gggggggggggggggg|
 91B2B3C0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
 91B2B3D0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
...

[helpful-fox-senko-san]

Never mind... I think this whole system is too convoluted just to catch an already bad situation of someone patching over modded dat files.

There should be no magic canary sections. It is too much of a risk that the patcher skips over portions of the file and expects them to be zero in a way that matters, and the code for doing all of this is a major liability.

This should be the data stored in the dat header:

0x210: 0x67676767
0x214: ORIGINAL_FILE_LENGTH / 8
0x218: MOD_DATA_OFFSET / 8

The modded data offset should be 16GB instead of 4GB, to minimize the chance of colliding with vanilla data. Anyone who zips/unzips or transfers their modded dat files over a network share can just deal with the increased disk space.

The only verification step that should be done, if any, is verifying the sparse range is still [ORIGINAL_FILE_LENGTH, MOD_DATA_OFFSET).

If the sparse range is unreadable, then we can still reuse an expanded file by assuming that vanilla data probably didn't suddenly blow past the 16GB barrier in dat7. That could be made slightly more robust by checking if a moderate, contiguous sequence of bytes before the 16GB mark are still all zeroes.

It wouldn't be safe to try and guess what the post-patch ORIGINAL_FILE_LENGTH should be. If anything the correct dat file lengths should be stored alongside of the index backups.

In picture form...

[helpful-fox-senko-san]

And the simplified pseudocode for the simplified scheme.

// TexTools marks dat files it created at offset 0x200
// There is an existing "ModifiedPartial" flag, but it gets treated the same as "ModifiedFull"
// To avoid indicating that a file is safe to be deleted (or written to below 16GB), mark the header at 0x210 instead
// Specifically: 0x210: 0x67676767
//               0x214: ORIGINAL_FILE_LENGTH / 8
//               0x218: MOD_DATA_OFFSET / 8
// Older versions of TT will just treat this file as vanilla
long DAT_PARTIALLY_MODDED_OFFSET = 0x210;
uint MAGIC_PARTIALLY_MODDED = 0x67676767;

// Only consider dat files smaller than 4GB for modding
// This could be increased up to 16GB, but having it be this small guarantees a larger buffer to catch patch writes
long MOD_ELIGIBLE_SIZE = (4L * 1024 * 1024 * 1024); // 4GB

// The offset we will actually write mod data
// This could be changed in the future or made dynamic in some way
long MOD_DATA_OFFSET = (16L * 1024 * 1024 * 1024); // 16GB

// The smallest modded data offset we'll accept from a dat file header
long MIN_MOD_DATA_OFFSET = (2L * 1024 * 1024 * 1024); // 2GB

// We reserve the first block of the modded data section for a magic signature
long MAGIC_67_LENGTH = 128;

enum CheckDatFileResult
{
	// The file is not eligible for modding (too large in size)
	NotEligible,
	// The file is eligible for modding and not already modded
	IsModdable,
	// The file contains modded data and passed all verification
	IsModded
};

// If the result is IsModded or IsModdable, we also return the mod data offset we'd like to use
// This is variable because we might want to pick a location other than 16GB in the future
(CheckDatFileResult Result, long OriginalFileLength, long ModDataOffset) CheckPartiallyModdedDatFile(File datFile)
{
	// A file less than 2GB is definitely not modded
	// This will be true every file that currently exists in the vanilla game
	// (except dat0 files, but we will never consider dat0 files anyway)
	if (datFile.Length < MIN_MOD_DATA_OFFSET)
		return (CheckDatFileResult.IsModdable, 0, MOD_DATA_OFFSET);

	// The mod data offset we read from the file
	long modDataOffset = 0;

	// Check if the file is partially modded already
	// A missing value isn't a guarantee, as the header could have been overwritten by the patcher
	bool hasHeader = false;
	datFile.Position = DAT_PARTIALLY_MODDED_OFFSET;
	if (datFile.ReadUInt() == MAGIC_PARTIALLY_MODDED)
	{
		// Extract the mod data offset we should have written in to the dat header
		datFile.ReadUInt(); // originalFileLength
		modDataOffset = (long)datFile.ReadUInt() * 8L;
		hasHeader = true;
		// Only accept a mod data offset that is greater than 2GB
		if (modDataOffset < MIN_MOD_DATA_OFFSET)
			modDataOffset = 0;
	}

	// If we didn't find an offset, the header could have just been overwritten!
	if (modDataOffset == 0)
	{
		// Check some offsets where we might expect to find our MAGIC67 signature written (2GB, 4GB, 8GB or 16GB)
		for (long eligibleOffset in [0x8000_0000, 0x1_0000_0000, 0x2_0000_0000, 0x4_0000_0000])
		{
			datFile.Position = eligibleOffset;
			var magic67Check = datFile.ReadBytes(MAGIC_67_LENGTH);
			bool magic67CheckFound = magic67Check.Length > 0 && magic67Check.All(b => b == 0x67);
			if (magic67CheckFound)
			{
				// It seems very likely that the file was modded
				// We don't immediately restore the header -- the dat writer can fix it later instead
				modDataOffset = eligibleOffset;
				return (CheckDatFileResult.IsModded, 0, modDataOffset);
			}
		}
	}

	// We didn't find any hint of the file being modded
	if (modDataOffset == 0)
	{
		// Do one final check if we consider the file eligible to become modded
		if (datFile.Length < MOD_ELIGIBLE_SIZE)
			return (CheckDatFileResult.IsModdable, 0, MOD_DATA_OFFSET);

		if (hasHeader)
			UnmarkPartiallyModdedDatFile(datFile);

		return (CheckDatFileResult.NotEligible, 0, 0);
	}

	// Extract and check the MAGIC67 area
	datFile.Position = modDataOffset;
	var magic67 = datFile.ReadBytes(MAGIC_67_LENGTH);
	bool magic67Intact = magic67.Length > 0 && magic67.All(b => b == 0x67);

	// Failure: The MAGIC67 section is not intact
	//          This implies that the file was patched *and* grew beyond 16GB
	if (!magic67Intact)
	{
		if (hasHeader)
			UnmarkPartiallyModdedDatFile(datFile);
		return (CheckDatFileResult.NotEligible, 0, 0);
	}

	// All checks completed: The dat file is modded.
	return (CheckDatFileResult.IsModded, originalFileLength, modDataOffset);
}

// Clear the "partially modded" flag from the header
void UnmarkPartiallyModdedDatFile(File datFile)
{
	datFile.Position = DAT_PARTIALLY_MODDED_OFFSET;
	datFile.WriteUInt(0);
	datFile.WriteUInt(0);
	datFile.WriteUInt(0);
}

// Clear all of the modded data
void ClearPartiallyModdedDatFile(File datFile, long originalFileLength, long modDataOffset)
{
	// We don't trust the original file length, because the file may have been patched to grow in size
	// Instead, we only trust the queried result for the sparse file range
	bool isSparse = IsFileSparse(datFile);

	if (isSparse)
	{
		// Find a region that ends at the beginning of the mod data offset
		for (auto region : GetSparseRegionsForFile(file))
		{
			isSparse = true;
			// If there is a region that ends immediately before the mod data offset, we found what we needed
			if ((region.Offset + region.Length) == modDataOffset)
			{
				// Round it up to the next multiple of 128 just in case
				originalFileLength = long.Max(originalFileLength, (region.Offset + 127) / 128 * 128);
				break;
			}
		}
	}
	else
	{
		// We don't know the original file length anymore, and the file is no longer sparse for some reason
		// We can run backwards from 16GB (down to 4GB minimum), deleting any chunks of contiguous zeroes we see
		// This won't shrink the file back down to its true original size, but it allows it to be reused for mods again
		// TODO: Optimize this part as it will be very slow
		const long zeroCheckLength = 4 * 1024 * 1024; // Seek backwards 4MB at a time...
		long checkMinimumOffset = long.Max(MOD_ELIGIBLE_SIZE, originalFileLength);
		for (long checkOffset = modDataOffset - zeroCheckLength; checkOffset > MOD_ELIGIBLE_SIZE; checkOffset -= zeroCheckLength)
		{
			datFile.Position = checkOffset;
			var zeroChunk = datFile.ReadBytes(checkOffset, ZeroCheckLength);
			if (zeroChunk.Any(c => c != 0))
				break;
			originalFileLength = checkOffset;
		}
	}

	// Shrink the file back down to its original file length (or our estimate)
	if (originalFileLength != 0)
	{
		datFile.Length = originalFileLength;
		MakeFileNotSparse(datFile);
	}
}

void CreatePartiallyModdedDatFile(File datFile, long modDataOffset)
{
	// If for some ungodly reason the dat file size is not divisible by 128, just pad it out
	datFile.Position = datFile.Length;
	while (datFile.Position % 128 != 0)
	{
		datFile.WriteByte(0);
		return false;
	}

	long originalFileLength = datFile.Length;

	var magic67 = new byte[MAGIC_67_LENGTH];
	Array.Fill(magic67, 0x67);

	MakeFileSparse(datFile);

	// Fill the gap between the vanilla and modded data with a sparse range (or a bunch of zeroes)
	ZeroSparseFileRange(datFile, zeroRangeBegin: originalFileLength, zeroRangeEnd: modDataOffset);

	// Write the MAGIC67 signature to the beginning of the modded data
	datFile.WriteBytes(magic67);

	// Finally, write a marker in to the header of the dat file to mark it as partially modded
	datFile.Position = DAT_PARTIALLY_MODDED_OFFSET;
	datFile.WriteUInt(DAT_PARTIALLY_MODDED_OFFSET, MAGIC_PARTIALLY_MODDED);
	datFile.WriteUInt(DAT_PARTIALLY_MODDED_OFFSET, (uint)(originalFileLength / 8));
	datFile.WriteUInt(DAT_PARTIALLY_MODDED_OFFSET, (uint)(modDataOffset / 8));
}