diff --git a/patch-bases/7fa480f6da5c8a987fe0940f1654e62db6f0b165/dmg/compress.c b/third_party/libdmg-hfsplus/src/dmg/compress.c
index 172cf6f2d86d4..4331c2a623f3e 100644
--- a/patch-bases/7fa480f6da5c8a987fe0940f1654e62db6f0b165/dmg/compress.c
+++ b/third_party/libdmg-hfsplus/src/dmg/compress.c
@@ -106,20 +106,20 @@ int getCompressor(Compressor* comp, char *name)
 {
   if (strcasecmp(name, "bzip2") == 0) {
     comp->block_type = BLOCK_BZIP2;
-    comp->compress = bz2Compress;
+    comp->compressFn = bz2Compress;
     comp->decompressBuffer = oldDecompressBuffer;
     return 0;
   }
   if (strcasecmp(name, "zlib") == 0) {
     comp->block_type = BLOCK_ZLIB;
-    comp->compress = zlibCompress;
+    comp->compressFn = zlibCompress;
     comp->decompressBuffer = oldDecompressBuffer;
     return 0;
   }
 #ifdef HAVE_LIBLZMA
   if (strcasecmp(name, "lzma") == 0) {
     comp->block_type = BLOCK_LZMA;
-    comp->compress = lzmaCompress;
+    comp->compressFn = lzmaCompress;
     comp->decompressBuffer = modernDecompressBuffer;
     return 0;
   }
@@ -127,7 +127,7 @@ int getCompressor(Compressor* comp, char *name)
 #ifdef HAVE_LZFSE
   if (strcasecmp(name, "lzfse") == 0) {
     comp->block_type = BLOCK_LZFSE;
-    comp->compress = lzfseCompress;
+    comp->compressFn = lzfseCompress;
     comp->decompressBuffer = modernDecompressBuffer;
     return 0;
   }
diff --git a/patch-bases/7fa480f6da5c8a987fe0940f1654e62db6f0b165/dmg/io.c b/third_party/libdmg-hfsplus/src/dmg/io.c
index 922612cf19d07..ec507cd4993ce 100644
--- a/patch-bases/7fa480f6da5c8a987fe0940f1654e62db6f0b165/dmg/io.c
+++ b/third_party/libdmg-hfsplus/src/dmg/io.c
@@ -137,7 +137,7 @@ static block* blockRead(threadData* d) {
 
 static void blockCompress(block* b, Compressor* comp) {
 	if (!b->keepRaw) {
-		ASSERT(comp->compress(b->inbuf, b->insize, b->outbuf, b->bufferSize, &b->outsize, comp->level) == 0, "compress");
+		ASSERT(comp->compressFn(b->inbuf, b->insize, b->outbuf, b->bufferSize, &b->outsize, comp->level) == 0, "compress");
 	}
 	
 	if(b->keepRaw || ((b->outsize / SECTOR_SIZE) >= (b->run.sectorCount - 15))) {
diff --git a/patch-bases/7fa480f6da5c8a987fe0940f1654e62db6f0b165/dmg/partition.c b/third_party/libdmg-hfsplus/src/dmg/partition.c
index ebab732f1e06e..aceb0f9782e0b 100644
--- a/patch-bases/7fa480f6da5c8a987fe0940f1654e62db6f0b165/dmg/partition.c
+++ b/third_party/libdmg-hfsplus/src/dmg/partition.c
@@ -521,7 +521,7 @@ int writeDriverDescriptorMap(int pNum, AbstractFile* file, DriverDescriptorRecor
   char pName[100];
   sprintf(pName, "Driver Descriptor Map (DDM : %d)", pNum + 1);
   *resources = insertData(*resources, "blkx", pNum, pName, 0, false, (const char*) blkx, sizeof(BLKXTable) + (blkx->blocksRunCount * sizeof(BLKXRun)), ATTRIBUTE_HDIUTIL);
-  
+
   bufferFile->close(bufferFile);
   free(buffer);
   free(blkx);
diff --git a/patch-bases/7fa480f6da5c8a987fe0940f1654e62db6f0b165/hfs/btree.c b/third_party/libdmg-hfsplus/src/hfs/btree.c
index 3aca4689dbb68..d31ff6d2bc5c9 100644
--- a/patch-bases/7fa480f6da5c8a987fe0940f1654e62db6f0b165/hfs/btree.c
+++ b/third_party/libdmg-hfsplus/src/hfs/btree.c
@@ -3,44 +3,44 @@
 
 BTNodeDescriptor* readBTNodeDescriptor(uint32_t num, BTree* tree) {
   BTNodeDescriptor* descriptor;
-  
+
   descriptor = (BTNodeDescriptor*) malloc(sizeof(BTNodeDescriptor));
-  
+
   if(!READ(tree->io, num * tree->headerRec->nodeSize, sizeof(BTNodeDescriptor), descriptor))
     return NULL;
-    
+
   FLIPENDIAN(descriptor->fLink);
   FLIPENDIAN(descriptor->bLink);
   FLIPENDIAN(descriptor->numRecords);
-  
+
   return descriptor;
 }
 
 static int writeBTNodeDescriptor(BTNodeDescriptor* descriptor, uint32_t num, BTree* tree) {
   BTNodeDescriptor myDescriptor;
-  
+
   myDescriptor = *descriptor;
 
   FLIPENDIAN(myDescriptor.fLink);
   FLIPENDIAN(myDescriptor.bLink);
   FLIPENDIAN(myDescriptor.numRecords);
-  
+
   if(!WRITE(tree->io, num * tree->headerRec->nodeSize, sizeof(BTNodeDescriptor), &myDescriptor))
     return FALSE;
-    
+
   return TRUE;
 }
 
 BTHeaderRec* readBTHeaderRec(io_func* io) {
   BTHeaderRec* headerRec;
- 
+
   headerRec = (BTHeaderRec*) malloc(sizeof(BTHeaderRec));
-  
+
   if(!READ(io, sizeof(BTNodeDescriptor), sizeof(BTHeaderRec), headerRec)) {
     free(headerRec);
     return NULL;
   }
-    
+
   FLIPENDIAN(headerRec->treeDepth);
   FLIPENDIAN(headerRec->rootNode);
   FLIPENDIAN(headerRec->leafRecords);
@@ -52,7 +52,7 @@ BTHeaderRec* readBTHeaderRec(io_func* io) {
   FLIPENDIAN(headerRec->freeNodes);
   FLIPENDIAN(headerRec->clumpSize);
   FLIPENDIAN(headerRec->attributes);
-  
+
   /*printf("treeDepth: %d\n", headerRec->treeDepth);
   printf("rootNode: %d\n", headerRec->rootNode);
   printf("leafRecords: %d\n", headerRec->leafRecords);
@@ -67,15 +67,15 @@ BTHeaderRec* readBTHeaderRec(io_func* io) {
   printf("keyCompareType: 0x%x\n", headerRec->keyCompareType);
   printf("attributes: 0x%x\n", headerRec->attributes);
   fflush(stdout);*/
-  
+
   return headerRec;
 }
 
 static int writeBTHeaderRec(BTree* tree) {
   BTHeaderRec headerRec;
-  
+
   headerRec = *tree->headerRec;
-  
+
   FLIPENDIAN(headerRec.treeDepth);
   FLIPENDIAN(headerRec.rootNode);
   FLIPENDIAN(headerRec.leafRecords);
@@ -87,32 +87,32 @@ static int writeBTHeaderRec(BTree* tree) {
   FLIPENDIAN(headerRec.freeNodes);
   FLIPENDIAN(headerRec.clumpSize);
   FLIPENDIAN(headerRec.attributes);
-  
+
   if(!WRITE(tree->io, sizeof(BTNodeDescriptor), sizeof(BTHeaderRec), &headerRec))
     return FALSE;
-    
+
   return TRUE;
 }
 
 
 BTree* openBTree(io_func* io, compareFunc compare, dataReadFunc keyRead, keyWriteFunc keyWrite, keyPrintFunc keyPrint, dataReadFunc dataRead) {
   BTree* tree;
-  
+
   tree = (BTree*) malloc(sizeof(BTree));
   tree->io = io;
   tree->headerRec = readBTHeaderRec(tree->io);
-  
+
   if(tree->headerRec == NULL) {
     free(tree);
     return NULL;
   }
-  
+
   tree->compare = compare;
   tree->keyRead = keyRead;
   tree->keyWrite = keyWrite;
   tree->keyPrint = keyPrint;
   tree->dataRead = dataRead;
-   
+
   return tree;
 }
 
@@ -125,17 +125,17 @@ void closeBTree(BTree* tree) {
 off_t getRecordOffset(int num, uint32_t nodeNum, BTree* tree) {
   uint16_t offset;
   off_t nodeOffset;
-  
+
   nodeOffset = nodeNum * tree->headerRec->nodeSize;
-  
+
   if(!READ(tree->io, nodeOffset + tree->headerRec->nodeSize - (sizeof(uint16_t) * (num + 1)), sizeof(uint16_t), &offset)) {
     hfs_panic("cannot get record offset!");
   }
-  
+
   FLIPENDIAN(offset);
-  
+
   //printf("%d: %d %d\n", nodeOffset + tree->headerRec->nodeSize - (sizeof(uint16_t) * (num + 1)), nodeOffset + offset, offset);
-  
+
   return (nodeOffset + offset);
 }
 
@@ -145,32 +145,32 @@ static off_t getFreeSpace(uint32_t nodeNum, BTNodeDescriptor* descriptor, BTree*
   off_t freespaceOffsetOffset;
   uint16_t offset;
   off_t freespaceOffset;
-  
+
   num = descriptor->numRecords;
-  
+
   nodeOffset = nodeNum * tree->headerRec->nodeSize;
   freespaceOffsetOffset = nodeOffset + tree->headerRec->nodeSize - (sizeof(uint16_t) * (num + 1));
-  
+
   if(!READ(tree->io, freespaceOffsetOffset, sizeof(uint16_t), &offset)) {
     hfs_panic("cannot get record offset!");
   }
-  
+
   FLIPENDIAN(offset);
-  
+
   freespaceOffset = nodeOffset + offset;
-  
+
   return (freespaceOffsetOffset - freespaceOffset);
 }
 
 off_t getNodeNumberFromPointerRecord(off_t offset, io_func* io) {
   uint32_t nodeNum;
-  
+
   if(!READ(io, offset, sizeof(uint32_t), &nodeNum)) {
     hfs_panic("cannot get node number from pointer record!");
   }
-  
+
   FLIPENDIAN(nodeNum);
-  
+
   return nodeNum;
 }
 
@@ -180,39 +180,39 @@ static void* searchNode(BTree* tree, uint32_t root, BTKey* searchKey, int *exact
   off_t recordOffset;
   off_t recordDataOffset;
   off_t lastRecordDataOffset;
-  
+
   int res;
   int i;
-  
+
   descriptor = readBTNodeDescriptor(root, tree);
-   
+
   if(descriptor == NULL)
     return NULL;
-    
+
   lastRecordDataOffset = 0;
-  
+
   for(i = 0; i < descriptor->numRecords; i++) {
     recordOffset = getRecordOffset(i, root, tree);
     key = READ_KEY(tree, recordOffset, tree->io);
     recordDataOffset = recordOffset + key->keyLength + sizeof(key->keyLength);
-    
+
     res = COMPARE(tree, key, searchKey);
     free(key);
     if(res == 0) {
       if(descriptor->kind == kBTLeafNode) {
         if(nodeNumber != NULL)
           *nodeNumber = root;
-          
+
         if(recordNumber != NULL)
           *recordNumber = i;
-        
+
         if(exact != NULL)
           *exact = TRUE;
-                 
+
         free(descriptor);
 
         return READ_DATA(tree, recordDataOffset, tree->io);
-      } else {  
+      } else {
         free(descriptor);
         return searchNode(tree, getNodeNumberFromPointerRecord(recordDataOffset, tree->io), searchKey, exact, nodeNumber, recordNumber);
       }
@@ -227,30 +227,30 @@ static void* searchNode(BTree* tree, uint32_t root, BTKey* searchKey, int *exact
     hfs_panic("BTree inconsistent!");
     return NULL;
   }
-  
-  if(descriptor->kind == kBTLeafNode) {        
+
+  if(descriptor->kind == kBTLeafNode) {
     if(nodeNumber != NULL)
       *nodeNumber = root;
-      
+
     if(recordNumber != NULL)
       *recordNumber = i;
-    
+
     if(exact != NULL)
       *exact = FALSE;
-      
+
     free(descriptor);
     return READ_DATA(tree, lastRecordDataOffset, tree->io);
   } else if(descriptor->kind == kBTIndexNode) {
-  
+
     free(descriptor);
     return searchNode(tree, getNodeNumberFromPointerRecord(lastRecordDataOffset, tree->io), searchKey, exact, nodeNumber, recordNumber);
   } else {
     if(nodeNumber != NULL)
       *nodeNumber = root;
-      
+
     if(recordNumber != NULL)
       *recordNumber = i;
-    
+
     if(exact != NULL)
       *exact = FALSE;
 
@@ -267,22 +267,22 @@ static uint32_t linearCheck(uint32_t* heightTable, unsigned char* map, BTree* tr
   uint8_t i;
   uint8_t j;
   uint32_t node;
-  
+
   uint32_t count;
   uint32_t leafRecords;
-  
+
   BTNodeDescriptor* descriptor;
-  
+
   uint32_t prevNode;
-  
+
   off_t recordOffset;
   BTKey* key;
   BTKey* previousKey;
-  
+
   count = 0;
-  
+
   leafRecords = 0;
-  
+
   for(i = 0; i <= tree->headerRec->treeDepth; i++) {
     node = heightTable[i];
     if(node != 0) {
@@ -293,39 +293,39 @@ static uint32_t linearCheck(uint32_t* heightTable, unsigned char* map, BTree* tr
         descriptor = readBTNodeDescriptor(node, tree);
       }
       free(descriptor);
-      
+
       prevNode = 0;
       previousKey = NULL;
-      
+
       if(i == 1) {
         if(node != tree->headerRec->firstLeafNode) {
           printf("BTREE CONSISTENCY ERROR: First leaf node (%d) is not correct. Should be: %d\n", tree->headerRec->firstLeafNode, node);
           (*errCount)++;
         }
       }
-      
+
       while(node != 0) {
         descriptor = readBTNodeDescriptor(node, tree);
         if(descriptor->bLink != prevNode) {
           printf("BTREE CONSISTENCY ERROR: Node %d is not properly linked with previous node %d\n", node, prevNode);
           (*errCount)++;
         }
-        
+
         if(descriptor->height != i) {
           printf("BTREE CONSISTENCY ERROR: Node %d (%d) is not properly linked with nodes of the same height %d\n", node, descriptor->height, i);
           (*errCount)++;
         }
-        
+
         if((map[node / 8] & (1 << (7 - (node % 8)))) == 0) {
           printf("BTREE CONSISTENCY ERROR: Node %d not marked allocated\n", node);
           (*errCount)++;
         }
-        
+
         /*if(descriptor->kind == kBTIndexNode && descriptor->numRecords < 2) {
           printf("BTREE CONSISTENCY ERROR: Node %d does not have at least two children\n", node);
           (*errCount)++;
         }*/
-        
+
         for(j = 0; j < descriptor->numRecords; j++) {
           recordOffset = getRecordOffset(j, node, tree);
           key = READ_KEY(tree, recordOffset, tree->io);
@@ -340,36 +340,36 @@ static uint32_t linearCheck(uint32_t* heightTable, unsigned char* map, BTree* tr
             }
             free(previousKey);
           }
-          
+
           if(i == 1) {
             leafRecords++;
           }
           previousKey = key;
         }
-        
+
         count++;
-        
+
         prevNode = node;
         node = descriptor->fLink;
         free(descriptor);
       }
-      
+
       if(i == 1) {
         if(prevNode != tree->headerRec->lastLeafNode) {
           printf("BTREE CONSISTENCY ERROR: Last leaf node (%d) is not correct. Should be: %d\n", tree->headerRec->lastLeafNode, node);
           (*errCount)++;
         }
       }
-      
+
       free(previousKey);
     }
   }
-  
+
   if(leafRecords != tree->headerRec->leafRecords) {
     printf("BTREE CONSISTENCY ERROR: leafRecords (%d) is not correct. Should be: %d\n", tree->headerRec->leafRecords, leafRecords);
     (*errCount)++;
   }
-  
+
   return count;
 }
 
@@ -381,36 +381,36 @@ static uint32_t traverseNode(uint32_t nodeNum, BTree* tree, unsigned char* map,
   BTKey* retFirstKey;
   BTKey* retLastKey;
   int i, j;
-  
+
   int res;
-  
+
   uint32_t count;
-  
+
   off_t recordOffset;
   off_t recordDataOffset;
-  
+
   off_t lastrecordDataOffset;
-  
+
   descriptor = readBTNodeDescriptor(nodeNum, tree);
-  
+
   previousKey = NULL;
-  
+
   count = 1;
-  
+
   if(displayTree) {
     for(i = 0; i < descriptor->height; i++) {
       printf("  ");
     }
   }
-  
+
   if(descriptor->kind == kBTLeafNode) {
     if(displayTree)
       printf("Leaf %d: %d", nodeNum, descriptor->numRecords);
-    
+
     if(descriptor->height != 1) {
       printf("BTREE CONSISTENCY ERROR: Leaf node %d does not have height 1\n", nodeNum); fflush(stdout);
       (*errCount)++;
-    }    
+    }
   } else if(descriptor->kind == kBTIndexNode) {
     if(displayTree)
       printf("Index %d: %d", nodeNum, descriptor->numRecords);
@@ -419,16 +419,16 @@ static uint32_t traverseNode(uint32_t nodeNum, BTree* tree, unsigned char* map,
     printf("BTREE CONSISTENCY ERROR: Unexpected node %d has kind %d\n", nodeNum, descriptor->kind); fflush(stdout);
     (*errCount)++;
   }
-  
+
   if(displayTree) {
     printf("\n"); fflush(stdout);
   }
-  
+
   if((map[nodeNum / 8] & (1 << (7 - (nodeNum % 8)))) == 0) {
     printf("BTREE CONSISTENCY ERROR: Node %d not marked allocated\n", nodeNum); fflush(stdout);
     (*errCount)++;
   }
-  
+
   if(nodeNum == tree->headerRec->rootNode) {
     if(descriptor->height != tree->headerRec->treeDepth) {
       printf("BTREE CONSISTENCY ERROR: Root node %d (%d) does not have the proper height (%d)\n", nodeNum,
@@ -441,20 +441,20 @@ static uint32_t traverseNode(uint32_t nodeNum, BTree* tree, unsigned char* map,
       (*errCount)++;
     }
   }
-  
+
   /*if(descriptor->kind == kBTIndexNode && descriptor->numRecords < 2) {
     printf("BTREE CONSISTENCY ERROR: Node %d does not have at least two children\n", nodeNum);
     (*errCount)++;
   }*/
-  
+
   heightTable[descriptor->height] = nodeNum;
   lastrecordDataOffset = 0;
-   
+
   for(i = 0; i < descriptor->numRecords; i++) {
     recordOffset = getRecordOffset(i, nodeNum, tree);
     key = READ_KEY(tree, recordOffset, tree->io);
     recordDataOffset = recordOffset + key->keyLength + sizeof(key->keyLength);
-    
+
     if((recordDataOffset - (nodeNum * tree->headerRec->nodeSize)) > (tree->headerRec->nodeSize - (sizeof(uint16_t) * (descriptor->numRecords + 1)))) {
       printf("BTREE CONSISTENCY ERROR: Record data extends past offsets in node %d record %d\n", nodeNum, i); fflush(stdout);
       (*errCount)++;
@@ -463,11 +463,11 @@ static uint32_t traverseNode(uint32_t nodeNum, BTree* tree, unsigned char* map,
     if(i == 0) {
       *firstKey = READ_KEY(tree, recordOffset, tree->io);
     }
-    
+
     if(i == (descriptor->numRecords - 1)) {
       *lastKey = READ_KEY(tree, recordOffset, tree->io);
     }
-    
+
     if(previousKey != NULL) {
       res = COMPARE(tree, key, previousKey);
       if(res < 0) {
@@ -481,7 +481,7 @@ static uint32_t traverseNode(uint32_t nodeNum, BTree* tree, unsigned char* map,
       free(previousKey);
       previousKey = NULL;
     }
-    
+
     if(displayTree) {
       for(j = 0; j < (descriptor->height - 1); j++) {
         printf("  ");
@@ -489,11 +489,11 @@ static uint32_t traverseNode(uint32_t nodeNum, BTree* tree, unsigned char* map,
       tree->keyPrint(key);
       printf("\n");
     }
-    
+
     if(descriptor->kind == kBTIndexNode) {
       count += traverseNode(getNodeNumberFromPointerRecord(recordDataOffset, tree->io),
                               tree, map, descriptor->height, &retFirstKey, &retLastKey, heightTable, errCount, displayTree);
-                              
+
       if(COMPARE(tree, retFirstKey, key) != 0) {
         printf("BTREE CONSISTENCY ERROR: Index node key does not match first key in record %d node %d\n", i, nodeNum); fflush(stdout);
         (*errCount)++;
@@ -508,41 +508,41 @@ static uint32_t traverseNode(uint32_t nodeNum, BTree* tree, unsigned char* map,
     } else {
       previousKey = key;
     }
-    
+
     if(recordOffset < lastrecordDataOffset) {
       printf("BTREE CONSISTENCY ERROR: Record offsets are not in order in node %d starting at record %d\n", nodeNum, i); fflush(stdout);
       (*errCount)++;
     }
-    
+
     lastrecordDataOffset = recordDataOffset;
   }
-  
+
   if(previousKey != NULL) free(previousKey);
 
   free(descriptor);
-  
+
   return count;
-  
+
 }
 
 static unsigned char* mapNodes(BTree* tree, uint32_t* numMapNodes, uint32_t* errCount) {
   unsigned char *map;
-  
+
   BTNodeDescriptor* descriptor;
-  
+
   unsigned char byte;
-  
+
   uint32_t totalNodes;
   uint32_t freeNodes;
-  
+
   uint32_t byteNumber;
   uint32_t byteTracker;
-  
+
   uint32_t mapNode;
-  
+
   off_t mapRecordStart;
   off_t mapRecordLength;
-  
+
   int i;
 
   map = (unsigned char *)malloc(tree->headerRec->totalNodes/8 + 1);
@@ -550,14 +550,14 @@ static unsigned char* mapNodes(BTree* tree, uint32_t* numMapNodes, uint32_t* err
   byteTracker = 0;
   freeNodes = 0;
   totalNodes = 0;
-  
+
   mapRecordStart = getRecordOffset(2, 0, tree);
   mapRecordLength = tree->headerRec->nodeSize - 256;
   byteNumber = 0;
   mapNode = 0;
-  
+
   *numMapNodes = 0;
-   
+
   while(TRUE) {
     while(byteNumber < mapRecordLength) {
       READ(tree->io, mapRecordStart + byteNumber, 1, &byte);
@@ -569,36 +569,36 @@ static unsigned char* mapNodes(BTree* tree, uint32_t* numMapNodes, uint32_t* err
           freeNodes++;
         }
         totalNodes++;
-        
+
         if(totalNodes == tree->headerRec->totalNodes)
           goto done;
       }
     }
-        
+
     descriptor = readBTNodeDescriptor(mapNode, tree);
     mapNode = descriptor->fLink;
     free(descriptor);
-    
+
     (*numMapNodes)++;
-    
+
     if(mapNode == 0) {
       printf("BTREE CONSISTENCY ERROR: Not enough map nodes allocated! Allocated for: %d, needed: %d\n", totalNodes, tree->headerRec->totalNodes);
       (*errCount)++;
       break;
     }
-    
+
     mapRecordStart = mapNode * tree->headerRec->nodeSize + 14;
     mapRecordLength = tree->headerRec->nodeSize - 20;
     byteNumber = 0;
   }
-  
+
   done:
-     
+
   if(freeNodes != tree->headerRec->freeNodes) {
     printf("BTREE CONSISTENCY ERROR: Free nodes %d differ from actually allocated %d\n", tree->headerRec->freeNodes, freeNodes);
     (*errCount)++;
   }
-  
+
   return map;
 }
 
@@ -607,21 +607,21 @@ int debugBTree(BTree* tree, int displayTree) {
   uint32_t *heightTable;
   BTKey* retFirstKey;
   BTKey* retLastKey;
-  
+
   uint32_t numMapNodes;
   uint32_t traverseCount;
   uint32_t linearCount;
   uint32_t errorCount;
-  
+
   uint8_t i;
-  
+
   errorCount = 0;
   traverseCount = 0;
   linearCount = 0;
-  
+
   printf("Mapping nodes...\n"); fflush(stdout);
   map = mapNodes(tree, &numMapNodes, &errorCount);
-  
+
   printf("Initializing height table...\n"); fflush(stdout);
   heightTable = (uint32_t*) malloc(sizeof(uint32_t) * (tree->headerRec->treeDepth + 1));
   for(i = 0; i <= tree->headerRec->treeDepth; i++) {
@@ -632,13 +632,13 @@ int debugBTree(BTree* tree, int displayTree) {
     if(tree->headerRec->firstLeafNode || tree->headerRec->lastLeafNode) {
       printf("BTREE CONSISTENCY ERROR: First leaf node (%d) and last leaf node (%d) inconsistent with empty BTree\n",
                 tree->headerRec->firstLeafNode, tree->headerRec->lastLeafNode);
-      
+
       // Try to see if we can get a linear count
       if(tree->headerRec->firstLeafNode != 0)
         heightTable[1] = tree->headerRec->firstLeafNode;
       else
         heightTable[1] = tree->headerRec->lastLeafNode;
-        
+
       linearCount = linearCheck(heightTable, map, tree, &errorCount);
     }
   } else {
@@ -651,7 +651,7 @@ int debugBTree(BTree* tree, int displayTree) {
     printf("Performing linear traversal...\n"); fflush(stdout);
     linearCount = linearCheck(heightTable, map, tree, &errorCount);
   }
-  
+
   printf("Total traverse nodes: %d\n", traverseCount); fflush(stdout);
   printf("Total linear nodes: %d\n", linearCount); fflush(stdout);
   printf("Error count: %d\n", errorCount); fflush(stdout);
@@ -659,15 +659,15 @@ int debugBTree(BTree* tree, int displayTree) {
   if(traverseCount != linearCount) {
     printf("BTREE CONSISTENCY ERROR: Linear count and traverse count are inconsistent\n");
   }
-  
+
   if(traverseCount != (tree->headerRec->totalNodes - tree->headerRec->freeNodes - numMapNodes - 1)) {
     printf("BTREE CONSISTENCY ERROR: Free nodes and total nodes (%d) and traverse count are inconsistent\n",
       tree->headerRec->totalNodes - tree->headerRec->freeNodes);
   }
 
   free(heightTable);
-  free(map); 
-  
+  free(map);
+
   return errorCount;
 }
 
@@ -675,19 +675,19 @@ static uint32_t findFree(BTree* tree) {
   unsigned char byte;
   uint32_t byteNumber;
   uint32_t mapNode;
-  
+
   BTNodeDescriptor* descriptor;
-  
+
   off_t mapRecordStart;
   off_t mapRecordLength;
-  
+
   int i;
 
   mapRecordStart = getRecordOffset(2, 0, tree);
   mapRecordLength = tree->headerRec->nodeSize - 256;
   mapNode = 0;
   byteNumber = 0;
-  
+
   while(TRUE) {
     while(byteNumber < mapRecordLength) {
       READ(tree->io, mapRecordStart + byteNumber, 1, &byte);
@@ -704,15 +704,15 @@ static uint32_t findFree(BTree* tree) {
       }
       byteNumber++;
     }
-    
+
     descriptor = readBTNodeDescriptor(mapNode, tree);
     mapNode = descriptor->fLink;
     free(descriptor);
-    
+
     if(mapNode == 0) {
       return 0;
     }
-    
+
     mapRecordStart = mapNode * tree->headerRec->nodeSize + 14;
     mapRecordLength = tree->headerRec->nodeSize - 20;
     byteNumber = 0;
@@ -723,9 +723,9 @@ static int markUsed(uint32_t node, BTree* tree) {
   BTNodeDescriptor* descriptor;
   uint32_t mapNode;
   uint32_t byteNumber;
-  
+
   unsigned char byte;
-  
+
   mapNode = 0;
   byteNumber = node / 8;
 
@@ -734,7 +734,7 @@ static int markUsed(uint32_t node, BTree* tree) {
       descriptor = readBTNodeDescriptor(mapNode, tree);
       mapNode = descriptor->fLink;
       free(descriptor);
-      
+
       if(byteNumber > (tree->headerRec->nodeSize - 20)) {
         byteNumber -= tree->headerRec->nodeSize - 20;
       } else {
@@ -742,11 +742,11 @@ static int markUsed(uint32_t node, BTree* tree) {
       }
     }
   }
-  
+
   ASSERT(READ(tree->io, mapNode * tree->headerRec->nodeSize + 14 + byteNumber, 1, &byte), "READ");
   byte |= (1 << (7 - (node % 8)));
   ASSERT(WRITE(tree->io, mapNode * tree->headerRec->nodeSize + 14 + byteNumber, 1, &byte), "WRITE");
-  
+
   return TRUE;
 }
 
@@ -754,25 +754,25 @@ static int growBTree(BTree* tree) {
   int i;
   unsigned char* buffer;
   uint16_t offset;
-  
+
   uint32_t byteNumber;
   uint32_t mapNode;
   int increasedNodes;
-  
+
   off_t newNodeOffset;
   uint32_t newNodesStart;
-  
+
   BTNodeDescriptor* descriptor;
   BTNodeDescriptor newDescriptor;
-  
+
   allocate((RawFile*)(tree->io->data), ((RawFile*)(tree->io->data))->forkData->logicalSize + ((RawFile*)(tree->io->data))->forkData->clumpSize);
   increasedNodes = (((RawFile*)(tree->io->data))->forkData->logicalSize/tree->headerRec->nodeSize) - tree->headerRec->totalNodes;
-  
+
   newNodesStart = tree->headerRec->totalNodes / tree->headerRec->nodeSize;
-  
+
   tree->headerRec->freeNodes += increasedNodes;
   tree->headerRec->totalNodes += increasedNodes;
-  
+
   byteNumber = tree->headerRec->totalNodes / 8;
   mapNode = 0;
 
@@ -780,14 +780,14 @@ static int growBTree(BTree* tree) {
   for(i = 0; i < (tree->headerRec->nodeSize - 20); i++) {
     buffer[i] = 0;
   }
-  
+
   if(byteNumber < (tree->headerRec->nodeSize - 256)) {
     ASSERT(writeBTHeaderRec(tree), "writeBTHeaderREc");
     free(buffer);
     return TRUE;
   } else {
     byteNumber -= tree->headerRec->nodeSize - 256;
-    
+
     while(TRUE) {
       descriptor = readBTNodeDescriptor(mapNode, tree);
       ASSERT(descriptor, "readBTNodeDescriptor failed in growBTree");
@@ -795,7 +795,7 @@ static int growBTree(BTree* tree) {
       if(descriptor->fLink == 0) {
         descriptor->fLink = newNodesStart;
         ASSERT(writeBTNodeDescriptor(descriptor, mapNode, tree), "growBTree failed to update existing descriptor");
-        
+
         newDescriptor.fLink = 0;
         newDescriptor.bLink = 0;
         newDescriptor.kind = kBTMapNode;
@@ -803,9 +803,9 @@ static int growBTree(BTree* tree) {
         newDescriptor.numRecords = 1;
         newDescriptor.reserved = 0;
         ASSERT(writeBTNodeDescriptor(&newDescriptor, descriptor->fLink, tree), "growBTree failed to create a new descriptor");
-        
+
         newNodeOffset = descriptor->fLink * tree->headerRec->nodeSize;
-        
+
         ASSERT(WRITE(tree->io, newNodeOffset + 14, tree->headerRec->nodeSize - 20, buffer), "WRITE");
         offset = 14;
         FLIPENDIAN(offset);
@@ -813,14 +813,14 @@ static int growBTree(BTree* tree) {
         offset = 14 + tree->headerRec->nodeSize - 20;
         FLIPENDIAN(offset);
         ASSERT(WRITE(tree->io, newNodeOffset + tree->headerRec->nodeSize - 4, sizeof(offset), &offset), "WRITE");
-        
+
         // mark the map node as being used
         ASSERT(markUsed(newNodesStart, tree), "markUsed");
         tree->headerRec->freeNodes--;
         newNodesStart++;
       }
       mapNode = descriptor->fLink;
-      
+
       if(byteNumber > (tree->headerRec->nodeSize - 20)) {
         byteNumber -= tree->headerRec->nodeSize - 20;
       } else {
@@ -832,7 +832,7 @@ static int growBTree(BTree* tree) {
       free(descriptor);
     }
   }
-  
+
   return FALSE;
 }
 
@@ -840,7 +840,7 @@ static uint32_t getNewNode(BTree* tree) {
   if(tree->headerRec->freeNodes == 0) {
     growBTree(tree);
   }
-  
+
   return findFree(tree);
 }
 
@@ -851,114 +851,114 @@ static uint32_t removeNode(BTree* tree, uint32_t node) {
   size_t mapRecordLength;
   BTNodeDescriptor *descriptor;
   BTNodeDescriptor *oDescriptor;
-  
+
   mapRecordStart = getRecordOffset(2, 0, tree);
   mapRecordLength = tree->headerRec->nodeSize - 256;
   mapNode = 0;
-    
+
   while((node / 8) >= mapRecordLength) {
     descriptor = readBTNodeDescriptor(mapNode, tree);
     mapNode = descriptor->fLink;
     free(descriptor);
-    
+
     if(mapNode == 0) {
       hfs_panic("Cannot remove node because I can't map it!");
       return 0;
     }
-    
+
     mapRecordStart = mapNode * tree->headerRec->nodeSize + 14;
     mapRecordLength = tree->headerRec->nodeSize - 20;
     node -= mapRecordLength * 8;
   }
-  
+
   READ(tree->io, mapRecordStart + (node / 8), 1, &byte);
-  
+
   byte &= ~(1 << (7 - (node % 8)));
-  
+
   tree->headerRec->freeNodes++;
-  
+
   descriptor = readBTNodeDescriptor(node, tree);
-  
+
   if(tree->headerRec->firstLeafNode == node) {
     tree->headerRec->firstLeafNode = descriptor->fLink;
   }
-  
+
   if(tree->headerRec->lastLeafNode == node) {
     tree->headerRec->lastLeafNode = descriptor->bLink;
   }
-  
+
   if(node == tree->headerRec->rootNode) {
     tree->headerRec->rootNode = 0;
   }
-  
+
   if(descriptor->bLink != 0) {
     oDescriptor = readBTNodeDescriptor(descriptor->bLink, tree);
     oDescriptor->fLink = descriptor->fLink;
     ASSERT(writeBTNodeDescriptor(oDescriptor, descriptor->bLink, tree), "writeBTNodeDescriptor");
 	free(oDescriptor);
   }
-  
+
   if(descriptor->fLink != 0) {
     oDescriptor = readBTNodeDescriptor(descriptor->fLink, tree);
     oDescriptor->bLink = descriptor->bLink;
     ASSERT(writeBTNodeDescriptor(oDescriptor, descriptor->fLink, tree), "writeBTNodeDescriptor");
 	free(oDescriptor);
   }
-  
+
   free(descriptor);
-  
+
   ASSERT(WRITE(tree->io, mapRecordStart + (node / 8), 1, &byte), "WRITE");
   ASSERT(writeBTHeaderRec(tree), "writeBTHeaderRec");
-  
+
   return TRUE;
 }
 
 static uint32_t splitNode(uint32_t node, BTNodeDescriptor* descriptor, BTree* tree) {
   int nodesToMove;
-  
+
   int i;
   off_t internalOffset;
-  
+
   BTNodeDescriptor* fDescriptor;
-  
+
   BTNodeDescriptor newDescriptor;
   uint32_t newNodeNum;
   off_t newNodeOffset;
-  
+
   off_t toMove;
   size_t toMoveLength;
   unsigned char *buffer;
-  
+
   off_t offsetsToMove;
   size_t offsetsToMoveLength;
   uint16_t *offsetsBuffer;
-    
+
   nodesToMove = descriptor->numRecords - (descriptor->numRecords/2);
-   
+
   toMove = getRecordOffset(descriptor->numRecords/2, node, tree);
   toMoveLength = getRecordOffset(descriptor->numRecords, node, tree) - toMove;
   buffer = (unsigned char *)malloc(toMoveLength);
   ASSERT(READ(tree->io, toMove, toMoveLength, buffer), "READ");
-  
+
   offsetsToMove = (node * tree->headerRec->nodeSize) + tree->headerRec->nodeSize - (sizeof(uint16_t) * (descriptor->numRecords + 1));
   offsetsToMoveLength = sizeof(uint16_t) * (nodesToMove + 1);
   offsetsBuffer = (uint16_t *)malloc(offsetsToMoveLength);
   ASSERT(READ(tree->io, offsetsToMove, offsetsToMoveLength, offsetsBuffer), "READ");
-  
+
   for(i = 0; i < (nodesToMove + 1); i++) {
     FLIPENDIAN(offsetsBuffer[i]);
   }
-  
+
   internalOffset = offsetsBuffer[nodesToMove] - 14;
-  
+
   for(i = 0; i < (nodesToMove + 1); i++) {
     offsetsBuffer[i] -= internalOffset;
     FLIPENDIAN(offsetsBuffer[i]);
   }
-  
+
   newNodeNum = getNewNode(tree);
   newNodeOffset = newNodeNum * tree->headerRec->nodeSize;
-  
+
   newDescriptor.fLink = descriptor->fLink;
   newDescriptor.bLink = node;
   newDescriptor.kind = descriptor->kind;
@@ -966,32 +966,32 @@ static uint32_t splitNode(uint32_t node, BTNodeDescriptor* descriptor, BTree* tr
   newDescriptor.numRecords = nodesToMove;
   newDescriptor.reserved = 0;
   ASSERT(writeBTNodeDescriptor(&newDescriptor, newNodeNum, tree), "writeBTNodeDescriptor");
-  
-  if(newDescriptor.fLink != 0) {    
+
+  if(newDescriptor.fLink != 0) {
     fDescriptor = readBTNodeDescriptor(newDescriptor.fLink, tree);
     fDescriptor->bLink = newNodeNum;
     ASSERT(writeBTNodeDescriptor(fDescriptor, newDescriptor.fLink, tree), "writeBTNodeDescriptor");
     free(fDescriptor);
   }
-  
+
   descriptor->fLink = newNodeNum;
   descriptor->numRecords = descriptor->numRecords/2;
   ASSERT(writeBTNodeDescriptor(descriptor, node, tree), "writeBTNodeDescriptor");
-  
+
   ASSERT(WRITE(tree->io, newNodeOffset + 14, toMoveLength, buffer), "WRITE");
   ASSERT(WRITE(tree->io, newNodeOffset + tree->headerRec->nodeSize - (sizeof(uint16_t) * (nodesToMove + 1)), offsetsToMoveLength, offsetsBuffer), "WRITE");
-  
+
   // The offset for the existing descriptor's new numRecords will happen to be where the old data was, which is now where the free space starts
   // So we don't have to manually set the free space offset
-  
+
   free(buffer);
   free(offsetsBuffer);
-  
+
   if(descriptor->kind == kBTLeafNode && node == tree->headerRec->lastLeafNode) {
     tree->headerRec->lastLeafNode = newNodeNum;
     ASSERT(writeBTHeaderRec(tree), "writeBTHeaderRec");
   }
-  
+
   return newNodeNum;
 }
 
@@ -999,33 +999,33 @@ static int moveRecordsDown(BTree* tree, BTNodeDescriptor* descriptor, int record
   off_t firstRecordStart;
   off_t lastRecordEnd;
   unsigned char* records;
-  
+
   off_t firstOffsetStart;
   off_t lastOffsetEnd;
   uint16_t* offsets;
-  
-  int i; 
-  
+
+  int i;
+
   firstRecordStart = getRecordOffset(record, node, tree);
   lastRecordEnd = getRecordOffset(descriptor->numRecords, node, tree);
-  
+
   records = (unsigned char*)malloc(lastRecordEnd - firstRecordStart);
-   
+
   ASSERT(READ(tree->io, firstRecordStart, lastRecordEnd - firstRecordStart, records), "READ");
   firstOffsetStart = (node * tree->headerRec->nodeSize) + tree->headerRec->nodeSize - (sizeof(uint16_t) * (descriptor->numRecords + 1));
   lastOffsetEnd = (node * tree->headerRec->nodeSize) + tree->headerRec->nodeSize - (sizeof(uint16_t) * record);
-  
+
   offsets = (uint16_t*)malloc(lastOffsetEnd - firstOffsetStart);
   ASSERT(READ(tree->io, firstOffsetStart, lastOffsetEnd - firstOffsetStart, offsets), "READ");
-  
+
   for(i = 0; i < (lastOffsetEnd - firstOffsetStart)/sizeof(uint16_t); i++) {
     FLIPENDIAN(offsets[i]);
     offsets[i] += length;
     FLIPENDIAN(offsets[i]);
   }
-  
+
   ASSERT(WRITE(tree->io, firstRecordStart + length, lastRecordEnd - firstRecordStart, records), "WRITE");
-  
+
   if(moveOffsets > 0) {
     ASSERT(WRITE(tree->io, firstOffsetStart - sizeof(uint16_t), lastOffsetEnd - firstOffsetStart, offsets), "WRITE");
   } else if(moveOffsets < 0) {
@@ -1033,10 +1033,10 @@ static int moveRecordsDown(BTree* tree, BTNodeDescriptor* descriptor, int record
   } else {
     ASSERT(WRITE(tree->io, firstOffsetStart, lastOffsetEnd - firstOffsetStart, offsets), "WRITE");
   }
-  
+
   free(records);
   free(offsets);
-  
+
   return TRUE;
 }
 
@@ -1051,45 +1051,45 @@ static int doAddRecord(BTree* tree, uint32_t root, BTKey* searchKey, size_t leng
 
   int res;
   int i;
-  
+
   descriptor = readBTNodeDescriptor(root, tree);
-   
+
   if(descriptor == NULL)
     return FALSE;
-    
+
   lastRecordDataOffset = 0;
-  
+
   for(i = 0; i < descriptor->numRecords; i++) {
     recordOffset = getRecordOffset(i, root, tree);
     key = READ_KEY(tree, recordOffset, tree->io);
     recordDataOffset = recordOffset + key->keyLength + sizeof(key->keyLength);
-    
+
     res = COMPARE(tree, key, searchKey);
     if(res == 0) {
       free(key);
       free(descriptor);
-      
+
       return FALSE;
     } else if(res > 0) {
       free(key);
-      
+
       break;
     }
-    
+
     free(key);
-    
+
     lastRecordDataOffset = recordDataOffset;
   }
-   
+
   if(i != descriptor->numRecords) {
     // first, move everyone else down
-    
+
     moveRecordsDown(tree, descriptor, i, root, sizeof(searchKey->keyLength) + searchKey->keyLength + length, 1);
-        
+
     // then insert ourself
     ASSERT(WRITE_KEY(tree, recordOffset, searchKey, tree->io), "WRITE_KEY");
     ASSERT(WRITE(tree->io, recordOffset + sizeof(searchKey->keyLength) + searchKey->keyLength, length, content), "WRITE");
-    
+
     offset = recordOffset - (root * tree->headerRec->nodeSize);
     FLIPENDIAN(offset);
     ASSERT(WRITE(tree->io, (root * tree->headerRec->nodeSize) + tree->headerRec->nodeSize - (sizeof(uint16_t) * (i + 1)),
@@ -1099,23 +1099,23 @@ static int doAddRecord(BTree* tree, uint32_t root, BTKey* searchKey, size_t leng
     recordOffset = getRecordOffset(i, root, tree);
     ASSERT(WRITE_KEY(tree, recordOffset, searchKey, tree->io), "WRITE_KEY");
     ASSERT(WRITE(tree->io, recordOffset + sizeof(uint16_t) + searchKey->keyLength, length, content), "WRITE");
-    
+
     // write the new free offset
     offset = (recordOffset + sizeof(searchKey->keyLength) + searchKey->keyLength + length) - (root * tree->headerRec->nodeSize);
     FLIPENDIAN(offset);
     ASSERT(WRITE(tree->io, (root * tree->headerRec->nodeSize) + tree->headerRec->nodeSize - (sizeof(uint16_t) * (descriptor->numRecords + 2)),
                   sizeof(uint16_t), &offset), "WRITE");
   }
-  
+
   descriptor->numRecords++;
-  
+
   if(descriptor->height == 1) {
     tree->headerRec->leafRecords++;
   }
 
   ASSERT(writeBTNodeDescriptor(descriptor, root, tree), "writeBTNodeDescriptor");
   ASSERT(writeBTHeaderRec(tree), "writeBTHeaderRec");
-  
+
   free(descriptor);
   return TRUE;
 }
@@ -1126,49 +1126,49 @@ static int addRecord(BTree* tree, uint32_t root, BTKey* searchKey, size_t length
   off_t recordOffset;
   off_t recordDataOffset;
   off_t lastRecordDataOffset;
-  
+
   size_t freeSpace;
-  
+
   int res;
   int i;
-  
+
   uint32_t newNode;
   uint32_t newNodeBigEndian;
-  
+
   uint32_t nodeBigEndian;
-  
+
   descriptor = readBTNodeDescriptor(root, tree);
-   
+
   if(descriptor == NULL)
     return 0;
-    
+
   freeSpace = getFreeSpace(root, descriptor, tree);
-  
+
   lastRecordDataOffset = 0;
-     
+
   for(i = 0; i < descriptor->numRecords; i++) {
     recordOffset = getRecordOffset(i, root, tree);
     key = READ_KEY(tree, recordOffset, tree->io);
     recordDataOffset = recordOffset + key->keyLength + sizeof(key->keyLength);
-    
+
     res = COMPARE(tree, key, searchKey);
     if(res == 0) {
       free(key);
       free(descriptor);
-      
+
       return 0;
     } else if(res > 0) {
       free(key);
-      
+
       break;
     }
-    
+
     free(key);
-    
+
     lastRecordDataOffset = recordDataOffset;
   }
-    
-  if(descriptor->kind == kBTLeafNode) {    
+
+  if(descriptor->kind == kBTLeafNode) {
     if(freeSpace < (sizeof(searchKey->keyLength) + searchKey->keyLength + length + sizeof(uint16_t))) {
       newNode = splitNode(root, descriptor, tree);
       if(i < descriptor->numRecords) {
@@ -1176,33 +1176,33 @@ static int addRecord(BTree* tree, uint32_t root, BTKey* searchKey, size_t length
       } else {
         doAddRecord(tree, newNode, searchKey, length, content);
       }
-      
+
       free(descriptor);
       return newNode;
     } else {
       doAddRecord(tree, root, searchKey, length, content);
-      
+
       free(descriptor);
       return 0;
     }
-  } else {  
+  } else {
     if(lastRecordDataOffset == 0) {
       if(descriptor->numRecords == 0) {
         hfs_panic("empty index node in btree");
         return 0;
       }
-      
+
       key = READ_KEY(tree, (root * tree->headerRec->nodeSize) + 14, tree->io);
-      
+
       recordDataOffset = recordOffset + key->keyLength + sizeof(key->keyLength);
       nodeBigEndian = getNodeNumberFromPointerRecord(recordDataOffset, tree->io);
-      
+
       FLIPENDIAN(nodeBigEndian);
-      
+
 	  free(key);
       key = READ_KEY(tree, (root * tree->headerRec->nodeSize) + 14, tree->io);
       recordDataOffset = recordOffset + key->keyLength + sizeof(key->keyLength);
-      
+
       if(searchKey->keyLength != key->keyLength) {
         if(searchKey->keyLength > key->keyLength && freeSpace < (searchKey->keyLength - key->keyLength)) {
           // very unlikely. We need to split this node before we can resize the key of this index. Do that first, and tell them to call again.
@@ -1212,19 +1212,19 @@ static int addRecord(BTree* tree, uint32_t root, BTKey* searchKey, size_t length
 
         moveRecordsDown(tree, descriptor, 1, root, searchKey->keyLength - key->keyLength, 0);
       }
-      
+
       free(key);
-      
+
       ASSERT(WRITE_KEY(tree, recordOffset, searchKey, tree->io), "WRITE_KEY");
       ASSERT(WRITE(tree->io, recordOffset + sizeof(uint16_t) + searchKey->keyLength, sizeof(uint32_t), &nodeBigEndian), "WRITE");
-      
+
       FLIPENDIAN(nodeBigEndian);
-      
+
       newNode = addRecord(tree, nodeBigEndian, searchKey, length, content, callAgain);
     } else {
       newNode = addRecord(tree, getNodeNumberFromPointerRecord(lastRecordDataOffset, tree->io), searchKey, length, content, callAgain);
     }
-    
+
     if(newNode == 0) {
       free(descriptor);
       return 0;
@@ -1232,22 +1232,22 @@ static int addRecord(BTree* tree, uint32_t root, BTKey* searchKey, size_t length
       newNodeBigEndian = newNode;
       key = READ_KEY(tree, newNode * tree->headerRec->nodeSize + 14, tree->io);
       FLIPENDIAN(newNodeBigEndian);
-      
+
       if(freeSpace < (sizeof(key->keyLength) + key->keyLength + sizeof(newNodeBigEndian) + sizeof(uint16_t))) {
         newNode = splitNode(root, descriptor, tree);
-        
+
         if(i < descriptor->numRecords) {
           doAddRecord(tree, root, key, sizeof(newNodeBigEndian), (unsigned char*)(&newNodeBigEndian));
         } else {
           doAddRecord(tree, newNode, key, sizeof(newNodeBigEndian), (unsigned char*)(&newNodeBigEndian));
         }
-        
+
         free(key);
         free(descriptor);
         return newNode;
       } else {
         doAddRecord(tree, root, key, sizeof(newNodeBigEndian), (unsigned char*)(&newNodeBigEndian));
-        
+
         free(key);
         free(descriptor);
         return 0;
@@ -1260,35 +1260,35 @@ static int increaseHeight(BTree* tree, uint32_t newNode) {
   uint32_t oldRoot;
   uint32_t newRoot;
   BTNodeDescriptor newDescriptor;
-  
+
   BTKey* oldRootKey;
   BTKey* newNodeKey;
-  
+
   uint16_t oldRootOffset;
   uint16_t newNodeOffset;
   uint16_t freeOffset;
-   
+
   oldRoot = tree->headerRec->rootNode;
-  
+
   oldRootKey = READ_KEY(tree, (oldRoot * tree->headerRec->nodeSize) + 14, tree->io);
   newNodeKey = READ_KEY(tree, (newNode * tree->headerRec->nodeSize) + 14, tree->io);
-  
+
   newRoot = getNewNode(tree);
-  
+
   newDescriptor.fLink = 0;
   newDescriptor.bLink = 0;
   newDescriptor.kind = kBTIndexNode;
   newDescriptor.height = tree->headerRec->treeDepth + 1;
   newDescriptor.numRecords = 2;
   newDescriptor.reserved = 0;
-  
+
   oldRootOffset = 14;
   newNodeOffset = oldRootOffset + sizeof(oldRootKey->keyLength) + oldRootKey->keyLength + sizeof(uint32_t);
   freeOffset = newNodeOffset + sizeof(newNodeKey->keyLength) + newNodeKey->keyLength + sizeof(uint32_t);
-  
+
   tree->headerRec->rootNode = newRoot;
   tree->headerRec->treeDepth = newDescriptor.height;
-  
+
   ASSERT(WRITE_KEY(tree, newRoot * tree->headerRec->nodeSize + oldRootOffset, oldRootKey, tree->io), "WRITE_KEY");
   FLIPENDIAN(oldRoot);
   ASSERT(WRITE(tree->io, newRoot * tree->headerRec->nodeSize + oldRootOffset + sizeof(oldRootKey->keyLength) + oldRootKey->keyLength,
@@ -1298,15 +1298,15 @@ static int increaseHeight(BTree* tree, uint32_t newNode) {
   FLIPENDIAN(newNode);
   ASSERT(WRITE(tree->io, newRoot * tree->headerRec->nodeSize + newNodeOffset + sizeof(newNodeKey->keyLength) + newNodeKey->keyLength,
                   sizeof(uint32_t), &newNode), "WRITE");
-  
+
   FLIPENDIAN(oldRootOffset);
   ASSERT(WRITE(tree->io, (newRoot * tree->headerRec->nodeSize) + tree->headerRec->nodeSize - (sizeof(uint16_t) * 1),
                   sizeof(uint16_t), &oldRootOffset), "WRITE");
-  
+
   FLIPENDIAN(newNodeOffset);
   ASSERT(WRITE(tree->io, (newRoot * tree->headerRec->nodeSize) + tree->headerRec->nodeSize - (sizeof(uint16_t) * 2),
                   sizeof(uint16_t), &newNodeOffset), "WRITE");
-                  
+
   FLIPENDIAN(freeOffset);
   ASSERT(WRITE(tree->io, (newRoot * tree->headerRec->nodeSize) + tree->headerRec->nodeSize - (sizeof(uint16_t) * 3),
                   sizeof(uint16_t), &freeOffset), "WRITE");
@@ -1315,7 +1315,7 @@ static int increaseHeight(BTree* tree, uint32_t newNode) {
   ASSERT(writeBTHeaderRec(tree), "writeBTHeaderRec");
 
   free(oldRootKey);
-  free(newNodeKey); 
+  free(newNodeKey);
   return TRUE;
 }
 
@@ -1325,7 +1325,7 @@ int addToBTree(BTree* tree, BTKey* searchKey, size_t length, unsigned char* cont
   uint16_t offset;
   uint16_t freeOffset;
   uint32_t newNode;
-  
+
   if(tree->headerRec->rootNode != 0) {
     do {
       callAgain = FALSE;
@@ -1341,25 +1341,25 @@ int addToBTree(BTree* tree, BTKey* searchKey, size_t length, unsigned char* cont
     tree->headerRec->lastLeafNode = tree->headerRec->rootNode;
     tree->headerRec->leafRecords = 1;
     tree->headerRec->treeDepth = 1;
-    
+
     newDescriptor.fLink = 0;
     newDescriptor.bLink = 0;
     newDescriptor.kind = kBTLeafNode;
     newDescriptor.height = 1;
     newDescriptor.numRecords = 1;
     newDescriptor.reserved = 0;
-    
+
     offset = 14;
     freeOffset = offset + sizeof(searchKey->keyLength) + searchKey->keyLength + length;
-    
-    ASSERT(WRITE_KEY(tree, tree->headerRec->rootNode * tree->headerRec->nodeSize + offset, searchKey, tree->io), "WRITE_KEY");    
+
+    ASSERT(WRITE_KEY(tree, tree->headerRec->rootNode * tree->headerRec->nodeSize + offset, searchKey, tree->io), "WRITE_KEY");
     ASSERT(WRITE(tree->io, tree->headerRec->rootNode * tree->headerRec->nodeSize + offset + sizeof(searchKey->keyLength) + searchKey->keyLength,
                   length, content), "WRITE");
-    
+
     FLIPENDIAN(offset);
     ASSERT(WRITE(tree->io, (tree->headerRec->rootNode * tree->headerRec->nodeSize) + tree->headerRec->nodeSize - (sizeof(uint16_t) * 1),
                     sizeof(uint16_t), &offset), "WRITE");
-    
+
     FLIPENDIAN(freeOffset);
     ASSERT(WRITE(tree->io, (tree->headerRec->rootNode * tree->headerRec->nodeSize) + tree->headerRec->nodeSize - (sizeof(uint16_t) * 2),
                     sizeof(uint16_t), &freeOffset), "WRITE");
@@ -1367,7 +1367,7 @@ int addToBTree(BTree* tree, BTKey* searchKey, size_t length, unsigned char* cont
     ASSERT(writeBTNodeDescriptor(&newDescriptor, tree->headerRec->rootNode, tree), "writeBTNodeDescriptor");
     ASSERT(writeBTHeaderRec(tree), "writeBTHeaderRec");
   }
-  
+
   return TRUE;
 }
 
@@ -1376,52 +1376,52 @@ static uint32_t removeRecord(BTree* tree, uint32_t root, BTKey* searchKey, int*
   int length;
   int i;
   int res;
-  
+
   uint32_t newNode;
   uint32_t nodeToTraverse;
   uint32_t newNodeBigEndian;
-  
+
   BTKey* key;
   off_t recordOffset;
   off_t recordDataOffset;
   off_t lastRecordDataOffset;
-  
+
   int childGone;
   int checkForChangedKey  ;
-  
+
   size_t freeSpace;
-  
+
   descriptor = readBTNodeDescriptor(root, tree);
-  
+
   freeSpace = getFreeSpace(root, descriptor, tree);
-  
+
   nodeToTraverse = 0;
   lastRecordDataOffset = 0;
   newNode = 0;
-  
+
   (*gone) = FALSE;
   checkForChangedKey = FALSE;
-    
+
   for(i = 0; i < descriptor->numRecords; i++) {
     recordOffset = getRecordOffset(i, root, tree);
     key = READ_KEY(tree, recordOffset, tree->io);
     recordDataOffset = recordOffset + key->keyLength + sizeof(key->keyLength);
-    
+
     res = COMPARE(tree, key, searchKey);
     if(res == 0) {
       free(key);
-      
+
       if(descriptor->kind == kBTLeafNode) {
         if(i != (descriptor->numRecords - 1)) {
           length = getRecordOffset(i + 1, root, tree) - recordOffset;
           moveRecordsDown(tree, descriptor, i + 1, root, -length, -1);
         } // don't need to do that if we're the last record, because our old offset pointer will be the new free space pointer
-               
+
         descriptor->numRecords--;
         tree->headerRec->leafRecords--;
         ASSERT(writeBTNodeDescriptor(descriptor, root, tree), "writeBTNodeDescriptor");
         ASSERT(writeBTHeaderRec(tree), "writeBTHeaderRec");
-        
+
         if(descriptor->numRecords >= 1) {
           free(descriptor);
           return 0;
@@ -1438,7 +1438,7 @@ static uint32_t removeRecord(BTree* tree, uint32_t root, BTKey* searchKey, int*
       }
     } else if(res > 0) {
       free(key);
-      
+
       if(lastRecordDataOffset == 0 || descriptor->kind == kBTLeafNode) {
         // not found;
         free(descriptor);
@@ -1448,94 +1448,94 @@ static uint32_t removeRecord(BTree* tree, uint32_t root, BTKey* searchKey, int*
         break;
       }
     }
-    
+
     lastRecordDataOffset = recordDataOffset;
-    
+
     free(key);
   }
-  
+
   if(nodeToTraverse == 0) {
     nodeToTraverse = getNodeNumberFromPointerRecord(lastRecordDataOffset, tree->io);
   }
-  
+
   if(i == descriptor->numRecords) {
     i = descriptor->numRecords - 1;
   }
-  
+
   newNode = removeRecord(tree, nodeToTraverse, searchKey, callAgain, &childGone);
-  
+
   if(childGone) {
     if(i != (descriptor->numRecords - 1)) {
       length = getRecordOffset(i + 1, root, tree) - recordOffset;
       moveRecordsDown(tree, descriptor, i + 1, root, -length, -1);
     } // don't need to do that if we're the last record, because our old offset pointer will be the new free space pointer
-           
+
     descriptor->numRecords--;
     ASSERT(writeBTNodeDescriptor(descriptor, root, tree), "writeBTNodeDescriptor");
   } else {
     if(checkForChangedKey) {
       // we will remove the first item in the child node, so our index has to change
-      
+
       key = READ_KEY(tree, getRecordOffset(0, nodeToTraverse, tree), tree->io);
-      
+
       if(searchKey->keyLength != key->keyLength) {
         if(key->keyLength > searchKey->keyLength && freeSpace < (key->keyLength - searchKey->keyLength)) {
           // very unlikely. We need to split this node before we can resize the key of this index. Do that first, and tell them to call again.
           *callAgain = TRUE;
           return splitNode(root, descriptor, tree);
         }
-        
+
         moveRecordsDown(tree, descriptor, i + 1, root, key->keyLength - searchKey->keyLength, 0);
       }
-      
+
       ASSERT(WRITE_KEY(tree, recordOffset, key, tree->io), "WRITE_KEY");
       FLIPENDIAN(nodeToTraverse);
       ASSERT(WRITE(tree->io, recordOffset + sizeof(uint16_t) + key->keyLength, sizeof(uint32_t), &nodeToTraverse), "WRITE");
       FLIPENDIAN(nodeToTraverse);
-      
+
       free(key);
     }
   }
-  
+
   if(newNode == 0) {
     if(descriptor->numRecords == 0) {
       removeNode(tree, root);
       (*gone) = TRUE;
     }
-    
+
     free(descriptor);
     return 0;
   } else {
     newNodeBigEndian = newNode;
     key = READ_KEY(tree, newNode * tree->headerRec->nodeSize + 14, tree->io);
     FLIPENDIAN(newNodeBigEndian);
-    
+
     if(freeSpace < (sizeof(key->keyLength) + key->keyLength + sizeof(newNodeBigEndian) + sizeof(uint16_t))) {
       newNode = splitNode(root, descriptor, tree);
-      
+
       if(i < descriptor->numRecords) {
         doAddRecord(tree, root, key, sizeof(newNodeBigEndian), (unsigned char*)(&newNodeBigEndian));
       } else {
         doAddRecord(tree, newNode, key, sizeof(newNodeBigEndian), (unsigned char*)(&newNodeBigEndian));
       }
-      
+
       if(descriptor->numRecords == 0) {
         removeNode(tree, root);
         (*gone) = TRUE;
       }
-      
+
       free(key);
       free(descriptor);
       return newNode;
     } else {
       doAddRecord(tree, root, key, sizeof(newNodeBigEndian), (unsigned char*)(&newNodeBigEndian));
-           
+
       free(key);
       free(descriptor);
       return 0;
     }
   }
-  
+
   return FALSE;
 }
 
@@ -1543,7 +1543,7 @@ int removeFromBTree(BTree* tree, BTKey* searchKey) {
   int callAgain;
   int gone;
   uint32_t newNode;
-  
+
   do {
     callAgain = FALSE;
     newNode = removeRecord(tree, tree->headerRec->rootNode, searchKey, &callAgain, &gone);
diff --git a/patch-bases/7fa480f6da5c8a987fe0940f1654e62db6f0b165/hfs/fastunicodecompare.c b/third_party/libdmg-hfsplus/src/hfs/fastunicodecompare.c
index 25793b3251dcd..454cb00da7a2f 100644
--- a/patch-bases/7fa480f6da5c8a987fe0940f1654e62db6f0b165/hfs/fastunicodecompare.c
+++ b/third_party/libdmg-hfsplus/src/hfs/fastunicodecompare.c
@@ -401,10 +401,10 @@ int32_t FastUnicodeCompare ( register uint16_t str1[], register uint16_t length1
                 c2 = lowerCaseTable[temp + (c2 & 0x00FF)];
         }
         if (c1 == ':') {
-		c1 = '/';
+            c1 = '/';
         }
         if (c2 == ':') {
-		c2 = '/';
+            c2 = '/';
         }
         if (c1 != c2)
             break;
diff --git a/patch-bases/7fa480f6da5c8a987fe0940f1654e62db6f0b165/includes/common.h b/third_party/libdmg-hfsplus/src/includes/common.h
index ec91b064c7016..4697c32d46ef2 100644
--- a/patch-bases/7fa480f6da5c8a987fe0940f1654e62db6f0b165/includes/common.h
+++ b/third_party/libdmg-hfsplus/src/includes/common.h
@@ -9,7 +9,7 @@
 #include <sys/types.h>
 
 // strlcpy looks useful, but not part of POSIX libc. BSD-inspired libc may
-// have it, but (as of 2025-Oct-2) Mozilla's build environment for 
+// have it, but (as of 2025-Oct-2) Mozilla's build environment for
 // libdmg-hfsplus doesn't.
 #ifdef strlcpy
 #undef strlcpy
diff --git a/patch-bases/7fa480f6da5c8a987fe0940f1654e62db6f0b165/includes/dmg/attribution.h b/third_party/libdmg-hfsplus/src/includes/dmg/attribution.h
index b13d1308dc84e..a84509cd8b869 100644
--- a/patch-bases/7fa480f6da5c8a987fe0940f1654e62db6f0b165/includes/dmg/attribution.h
+++ b/third_party/libdmg-hfsplus/src/includes/dmg/attribution.h
@@ -30,31 +30,31 @@
   // part of a Base64 encoded struct.  We can Base64 decode to bytes,
   // swizzle the 4 bytes of the checksum, and then Base64 encode back
   // to the same number of bytes.
-	/* <dict> */
-	/* 	<key>blkx</key> */
-	/* 	<array> */
-	/* 		<dict> */
-	/* 			<key>Attributes</key> */
-	/* 			<string>0x0050</string> */
-	/* 			<key>CFName</key> */
-	/* 			<string>Driver Descriptor Map (DDM : 0)</string> */
-	/* 			<key>Data</key> */
-	/* 			<data> */
-	/* 			bWlzaAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAA */
-	/* 			AAII/////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA */
-	/* 			AAIAAAAgXDMYCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA */
-	/* 			AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA */
-	/* 			AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA */
-	/* 			AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA */
-	/* 			AAAAAAACgAAABgAAAAAAAAAAAAAAAAAAAAAAAAABAAAA */
-	/* 			AAAAAAAAAAAAAAAANf////8AAAAAAAAAAAAAAAEAAAAA */
-	/* 			AAAAAAAAAAAAAAA1AAAAAAAAAAA= */
-	/* 			</data> */
-	/* 			<key>ID</key> */
-	/* 			<string>-1</string> */
-	/* 			<key>Name</key> */
-	/* 			<string>Driver Descriptor Map (DDM : 0)</string> */
-	/* 		</dict> */
+  /* <dict> */
+  /*  <key>blkx</key> */
+  /*  <array> */
+  /*    <dict> */
+  /*      <key>Attributes</key> */
+  /*      <string>0x0050</string> */
+  /*      <key>CFName</key> */
+  /*      <string>Driver Descriptor Map (DDM : 0)</string> */
+  /*      <key>Data</key> */
+  /*      <data> */
+  /*      bWlzaAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAA */
+  /*      AAII/////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA */
+  /*      AAIAAAAgXDMYCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA */
+  /*      AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA */
+  /*      AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA */
+  /*      AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA */
+  /*      AAAAAAACgAAABgAAAAAAAAAAAAAAAAAAAAAAAAABAAAA */
+  /*      AAAAAAAAAAAAAAAANf////8AAAAAAAAAAAAAAAEAAAAA */
+  /*      AAAAAAAAAAAAAAA1AAAAAAAAAAA= */
+  /*      </data> */
+  /*      <key>ID</key> */
+  /*      <string>-1</string> */
+  /*      <key>Name</key> */
+  /*      <string>Driver Descriptor Map (DDM : 0)</string> */
+  /*     </dict> */
 
 /**
  * Binary representation of data needed to quickly "attribute" a DMG that is
diff --git a/patch-bases/7fa480f6da5c8a987fe0940f1654e62db6f0b165/includes/dmg/compress.h b/third_party/libdmg-hfsplus/src/includes/dmg/compress.h
index ef4126b7b8bf5..9647cb177c14d 100644
--- a/patch-bases/7fa480f6da5c8a987fe0940f1654e62db6f0b165/includes/dmg/compress.h
+++ b/third_party/libdmg-hfsplus/src/includes/dmg/compress.h
@@ -20,7 +20,7 @@ typedef int (*CompressFunc)(unsigned char *inBuffer, size_t inSize,
 typedef size_t (*DecompressBufferFunc)(size_t runSectors);
 
 typedef struct {
-  CompressFunc compress;
+  CompressFunc compressFn;
   DecompressBufferFunc decompressBuffer;
   int level;
   uint32_t block_type;
diff --git a/patch-bases/7fa480f6da5c8a987fe0940f1654e62db6f0b165/includes/hfs/hfsplus.h b/third_party/libdmg-hfsplus/src/includes/hfs/hfsplus.h
index e62bd3b8d2a50..a6f51caf37265 100644
--- a/patch-bases/7fa480f6da5c8a987fe0940f1654e62db6f0b165/includes/hfs/hfsplus.h
+++ b/third_party/libdmg-hfsplus/src/includes/hfs/hfsplus.h
@@ -70,7 +70,7 @@ struct HFSPlusForkData {
 	HFSPlusExtentRecord extents;
 } __attribute__((__packed__));
 typedef struct HFSPlusForkData HFSPlusForkData;
- 
+
 struct HFSPlusVolumeHeader {
 	uint16_t signature;
 	uint16_t version;
@@ -178,7 +178,7 @@ struct Rect {
 } __attribute__((__packed__));
 typedef struct Rect   Rect;
 
-/* OSType is a 32-bit value made by packing four 1-byte characters 
+/* OSType is a 32-bit value made by packing four 1-byte characters
    together. */
 typedef uint32_t        FourCharCode;
 typedef FourCharCode    OSType;
@@ -190,19 +190,19 @@ enum {
 	kIsOnDesk       = 0x0001,     /* Files and folders (System 6) */
 	kColor          = 0x000E,     /* Files and folders */
 	kIsShared       = 0x0040,     /* Files only (Applications only) If */
-								  /* clear, the application needs */
-								  /* to write to its resource fork, */
-								  /* and therefore cannot be shared */
-								  /* on a server */
+	                              /* clear, the application needs */
+	                              /* to write to its resource fork, */
+	                              /* and therefore cannot be shared */
+	                              /* on a server */
 	kHasNoINITs     = 0x0080,     /* Files only (Extensions/Control */
-								  /* Panels only) */
-								  /* This file contains no INIT resource */
+	                              /* Panels only) */
+	                              /* This file contains no INIT resource */
 	kHasBeenInited  = 0x0100,     /* Files only.  Clear if the file */
-								  /* contains desktop database resources */
-								  /* ('BNDL', 'FREF', 'open', 'kind'...) */
-								  /* that have not been added yet.  Set */
-								  /* only by the Finder. */
-								  /* Reserved for folders */
+	                              /* contains desktop database resources */
+	                              /* ('BNDL', 'FREF', 'open', 'kind'...) */
+	                              /* that have not been added yet.  Set */
+	                              /* only by the Finder. */
+	                              /* Reserved for folders */
 	kHasCustomIcon  = 0x0400,     /* Files and folders */
 	kIsStationery   = 0x0800,     /* Files only */
 	kNameLocked     = 0x1000,     /* Files and folders */
@@ -214,11 +214,11 @@ enum {
 /* Extended flags (extendedFinderFlags, fdXFlags and frXFlags) */
 enum {
 	kExtendedFlagsAreInvalid    = 0x8000, /* The other extended flags */
-										  /* should be ignored */
+	                                      /* should be ignored */
 	kExtendedFlagHasCustomBadge = 0x0100, /* The file or folder has a */
-										  /* badge resource */
+	                                      /* badge resource */
 	kExtendedFlagHasRoutingInfo = 0x0004  /* The file contains routing */
-										  /* info resource */
+	                                      /* info resource */
 };
 
 enum {
@@ -245,11 +245,11 @@ typedef struct ExtendedFileInfo   ExtendedFileInfo;
 
 struct FolderInfo {
 	Rect        windowBounds;     /* The position and dimension of the */
-								  /* folder's window */
+	                              /* folder's window */
 	uint16_t    finderFlags;
 	Point       location;         /* Folder's location in the parent */
-								  /* folder. If set to {0, 0}, the Finder */
-								  /* will place the item automatically */
+	                              /* folder. If set to {0, 0}, the Finder */
+	                              /* will place the item automatically */
 	uint16_t    reservedField;
 } __attribute__((__packed__));
 typedef struct FolderInfo   FolderInfo;
@@ -321,28 +321,25 @@ enum {
 	kHFSPlusFileThreadRecord    = 0x0004   /* HFSPlusCatalogThread */
 };
 
-/* Flags enum for HFSPlusCatalogFolder and HFSPlusCatalogFile types. The
-   location that would contain these flags is reserved in HFSPlusCatalogThread.
-	 Stored as `uint16_t flags` in the two types where it is specified. */
 enum {
 	kHFSFileLockedBit       = 0x0000,       /* file is locked and cannot be written to */
 	kHFSFileLockedMask      = 0x0001,
-	
+
 	kHFSThreadExistsBit     = 0x0001,       /* a file thread record exists for this file */
 	kHFSThreadExistsMask    = 0x0002,
-	
+
 	kHFSHasAttributesBit    = 0x0002,       /* object has extended attributes */
 	kHFSHasAttributesMask   = 0x0004,
-	
+
 	kHFSHasSecurityBit      = 0x0003,       /* object has security data (ACLs) */
 	kHFSHasSecurityMask     = 0x0008,
-	
+
 	kHFSHasFolderCountBit   = 0x0004,       /* only for HFSX, folder maintains a separate sub-folder count */
 	kHFSHasFolderCountMask  = 0x0010,       /* (sum of folder records and directory hard links) */
-	
+
 	kHFSHasLinkChainBit     = 0x0005,       /* has hardlink chain (inode or link) */
 	kHFSHasLinkChainMask    = 0x0020,
-	
+
 	kHFSHasChildLinkBit     = 0x0006,       /* folder has a child that's a dir link */
 	kHFSHasChildLinkMask    = 0x0040
 };
@@ -448,8 +445,8 @@ enum {
 
 /* HFSPlusCatalogRecord contains a record for some item inside an HFSPlus file
    system's catalog, of indefinite size. Use the recordType field to
-	determine how to interpret the record (generally by casting the pointer to
-	HFSPlusCatalogFolder, HFSPlusCatalogFile, or HFSPlusCatalogThread). **/
+   determine how to interpret the record (generally by casting the pointer to
+   FSPlusCatalogFolder, HFSPlusCatalogFile, or HFSPlusCatalogThread). */
 struct HFSPlusCatalogRecord {
 	int16_t recordType;
 	unsigned char data[0];
@@ -458,7 +455,7 @@ typedef struct HFSPlusCatalogRecord HFSPlusCatalogRecord;
 
 /* CatalogRecordList is a singly-linked list of HFSPlusCatalogRecord entries,
    each associated with a name. To recursively free CatalogRecordList, use
-	 releaseCatalogRecordList(CatalogRecordList*). */
+   releaseCatalogRecordList(CatalogRecordList*). */
 struct CatalogRecordList {
 	HFSUniStr255 name;
 	HFSPlusCatalogRecord* record;
@@ -467,9 +464,9 @@ struct CatalogRecordList {
 typedef struct CatalogRecordList CatalogRecordList;
 
 /* XAttrList is a singly-linked list of extended attribute names. Names are
- * null-terminated Unicode strings uniquely owned by the XAttrList instance.
- * The owner of the list is responsible for walking the list and recursively
- * freeing all data in it when the list should be disposed. */
+   null-terminated Unicode strings uniquely owned by the XAttrList instance.
+   The owner of the list is responsible for walking the list and recursively
+   freeing all data in it when the list should be disposed. */
 struct XAttrList {
   char* name;
   struct XAttrList* next;
