Compare commits

...

1 Commits

4 changed files with 536 additions and 137 deletions

View File

@@ -58,8 +58,8 @@ ziU8 ZADP_Zi8SetPDremoveOpt(ziU8 option ZI_NEED_WORK) {
}
ziU32 Zi8MatchPUDdata_ZHS(ziWChar* pattern, ziU8 length, ziU8 language, ziWChar* output, ziU16 capacity, ziWChar* spelling, ziU16 spellingCapacity, ziU8 complete, ziU8 continuation ZI_NEED_WORK) {
ziWChar folded;
ziU32 entrySize, wordSize, copied;
ziU8* entry;
ziU32 entrySize;
int wordSize, copied;
ziU8* word;
int index;
int fallback = 0;
@@ -70,18 +70,18 @@ ziU32 Zi8MatchPUDdata_ZHS(ziWChar* pattern, ziU8 length, ziU8 language, ziWChar*
return 0;
}
if (language == 1) {
length &= 0x7F;
length *= 2;
}
if (continuation == 0) {
table = (ziPudHeader*)ZI_WORK->pudTable[ZI_WORK->pudCount - 1];
index = 0;
section = table->sections;
while (index < table->languageCount && section->language != language) {
index = 0;
while (index < table->languageCount) {
if (section->language == language) break;
index++;
section++;
}
if (table->languageCount <= index) {
if (index >= table->languageCount) {
Zi8LogError(0x4F6, __zi8_work_data);
return 0;
}
@@ -90,78 +90,82 @@ ziU32 Zi8MatchPUDdata_ZHS(ziWChar* pattern, ziU8 length, ziU8 language, ziWChar*
ZI_WORK->unk_0x318 = 0;
}
for (;;) {
entry = (ziU8*)ZI_WORK->unk_0x310;
if (entry == 0) {
word = (ziU8*)ZI_WORK->unk_0x310;
if (word == 0) {
Zi8LogError(0x4B3, __zi8_work_data);
return 0;
}
while ((ziS32)ZI_WORK->unk_0x318 < (ziS32)ZI_WORK->unk_0x314) {
word = entry + 1;
wordSize = *entry;
wordSize = *word++;
entrySize = wordSize;
if (language == 1) {
if (*word < ZI_WORK->unk_0x17) goto next;
if (ZI_WORK->unk_0x17 > *word) goto next;
entrySize = wordSize - 1;
word = entry + 2;
word++;
wordSize = ZiGetZHWordSize((ziWChar*)word, entrySize);
} else if (ZI_WORK->unk_0x31E != 0 && complete != 0 && wordSize > length && word[length] == 0x20) goto matchText;
if ((ziS32)length > (ziS32)wordSize || (complete != 0 && wordSize != length) || (complete == 0 && wordSize == length)) goto next;
if (language == 1) {
for (index = 0; index < length; index++) {
if (word[index] != ((ziU8*)pattern)[index]) goto next;
}
goto matched;
}
matchText:
for (index = 0; index < length; index++) {
if (pattern[index] < 0xEFF1 || pattern[index] > 0xF37F) {
folded = Zi8ConvertUC2WC(word[index], language, __zi8_work_data);
if (folded != pattern[index] && (!ZI_WORK->unk_0x1F || !Zi8ChangeCharCase(0, &folded, language, __zi8_work_data) || folded != pattern[index])) goto next;
} else if (pattern[index] != Zi8ConvertUC2Key(word[index], language, __zi8_work_data)) goto next;
}
matched:
if (fallback) {
ZI_WORK->unk_0x310 = 0;
ZI_WORK->unk_0x318 = 0;
ZI_WORK->unk_0x314 = 0;
if (*pattern < 0xEFF1) *output = Zi8ConvertWC2Key(*pattern, language, __zi8_work_data);
else *output = *pattern;
return 1;
}
if (language == 1) {
index = 0;
for (copied = 0; index < (ziS32)wordSize && copied < capacity; copied++) {
((ziU8*)output)[index] = word[index];
((ziU8*)output)[index + 1] = word[index + 1];
index += 2;
}
Zi8CopyZHSpelling(word, spelling, spellingCapacity, entrySize, wordSize);
if ((ziS32)length > (ziS32)wordSize || (complete != 0 && wordSize != length) || (complete == 0 && wordSize == length)) {
next:
ZI_WORK->unk_0x318++;
word += entrySize;
} else {
for (copied = 0; copied < wordSize && copied < capacity; copied++) {
output[copied] = Zi8ConvertUC2WC(word[copied], language, __zi8_work_data);
if (ZI_WORK->unk_0x31E != 0 && copied >= length && output[copied] == 0x20) {
if (complete != 0 || copied >= length) break;
goto next;
if (language == 1) {
for (index = 0; index < length; index++) {
if (word[index] != ((ziU8*)pattern)[index]) goto next;
}
goto matched;
}
matchText:
for (index = 0; index < length; index++) {
if (pattern[index] >= 0xEFF1 && pattern[index] <= 0xF37F) {
if (pattern[index] != Zi8ConvertUC2Key(word[index], language, __zi8_work_data)) goto next;
} else {
folded = Zi8ConvertUC2WC(word[index], language, __zi8_work_data);
if (folded != pattern[index] && (!ZI_WORK->unk_0x1F || !Zi8ChangeCharCase(0, &folded, language, __zi8_work_data) || folded != pattern[index])) goto next;
}
}
matched:
if (fallback) {
ZI_WORK->unk_0x310 = 0;
ZI_WORK->unk_0x318 = 0;
ZI_WORK->unk_0x314 = 0;
if (*pattern >= 0xEFF1) *output = *pattern;
else *output = Zi8ConvertWC2Key(*pattern, language, __zi8_work_data);
return 1;
}
if (language == 1) {
index = 0;
for (copied = 0; index < (ziS32)wordSize && copied < capacity; copied++) {
((ziU8*)output)[index] = word[index];
((ziU8*)output)[index + 1] = word[index + 1];
index += 2;
}
Zi8CopyZHSpelling(word, spelling, spellingCapacity, entrySize, wordSize);
} else {
for (copied = 0; copied < wordSize && copied < capacity; copied++) {
output[copied] = Zi8ConvertUC2WC(word[copied], language, __zi8_work_data);
if (ZI_WORK->unk_0x31E != 0 && copied >= length && output[copied] == 0x20) {
if (complete != 0 || copied >= length) break;
goto next;
}
}
}
ZI_WORK->unk_0x318++;
ZI_WORK->unk_0x310 = (ziU32)(word + entrySize);
Zi8LogError(100, __zi8_work_data);
return (ziU8)copied;
}
ZI_WORK->unk_0x318++;
ZI_WORK->unk_0x310 = (ziU32)(word + entrySize);
Zi8LogError(100, __zi8_work_data);
return (ziU8)copied;
next:
ZI_WORK->unk_0x318++;
entry = word + entrySize;
}
if (length != 1 || complete == 0 || continuation != 0) {
if (length == 1 && complete != 0 && continuation == 0) {
complete = 0;
fallback = 1;
ZI_WORK->unk_0x318 = 0;
} else {
ZI_WORK->unk_0x310 = 0;
ZI_WORK->unk_0x318 = 0;
ZI_WORK->unk_0x314 = 0;
return 0;
}
complete = 0;
fallback = 1;
ZI_WORK->unk_0x318 = 0;
}
}
ziU32 Zi8MatchPUDdata(ziWChar* pattern, ziU8 length, ziU8 language, ziWChar* output, ziU16 capacity, ziU8 complete, ziU8 continuation ZI_NEED_WORK) {

View File

@@ -42,39 +42,41 @@ ziU32 ZiDAWGGetChild(ziU32 node) {
return node;
}
ziU8* ZiDAWGGetSibling(ziU8* node) {
ziU8* ZiDAWGGetSibling(ziU8* cursor) {
ziU16 header;
ziU8* cursor = node;
ziU8* node;
ziS32 depth;
ziS32 offset;
depth = 0;
node = cursor;
offset = 0;
header = nodeHeaderTable[node[0] >> 4];
header = nodeHeaderTable[cursor[0] >> 4];
if ((header & 4) == 0) {
node = 0;
return 0;
} else {
if ((header & 8) != 0) {
if ((node[0] & 0xf) == 0xf) {
node += 2;
if ((cursor[0] & 0xf) == 0xf) {
cursor += 2;
} else {
node += 1;
cursor += 1;
}
if ((header & 2) != 0) {
if ((*node & 0x80) == 0) {
node += 2;
if ((*cursor & 0x80) != 0) {
cursor += 3;
} else {
node += 3;
cursor += 2;
}
}
if ((*node & 0x80) != 0) {
node += (*node & 0x7f) * 0x10000 + (ziU32)node[1] * 0x100 +
(ziU32)node[2] + 0x8000;
if ((*cursor & 0x80) != 0) {
node += (*cursor & 0x7f) * 0x10000 + (ziU32)cursor[1] * 0x100 +
(ziU32)cursor[2] + 0x8000;
} else {
node += (ziU16)*node * 0x100 + (ziU32)node[1];
node = cursor[1] + (node + (ziU16)*cursor * 0x100);
}
return node;
} else {
cursor = node;
do {
@@ -88,14 +90,16 @@ ziU8* ZiDAWGGetSibling(ziU8* node) {
}
if ((header & 1) != 0) {
if ((header & 2) == 0) {
depth++;
} else if ((*cursor & 0x80) != 0) {
cursor += 3;
offset += 3;
if ((header & 2) != 0) {
if ((*cursor & 0x80) != 0) {
cursor += 3;
offset += 3;
} else {
cursor += 2;
offset += 2;
}
} else {
cursor += 2;
offset += 2;
depth++;
}
}
@@ -113,11 +117,10 @@ ziU8* ZiDAWGGetSibling(ziU8* node) {
}
} while (0 < depth);
node += offset;
return node + offset;
}
}
return node;
}
ziU8 ZiDAWGgetEOWattribute(ziU32 node) {
@@ -158,57 +161,52 @@ ziU32 ZiDAWGGetGraphInfo(zi8DawgCtx* context, ziU8* entry, ziU16* keys) {
ziS32 result;
ziU32 end;
ziU8 depth;
ziU32 pair;
graph = ZiDAWGGetGraph(context);
result = 0;
pair = (((ziU16)entry[0] << 8) + entry[1]);
if (pair != 0) {
if ((((ziU16)entry[0] << 8) + entry[1]) != 0 || (((ziU16)entry[2] << 8) + entry[3]) != 0) {
return 0;
}
pair = (((ziU16)entry[2] << 8) + entry[3]);
if (pair == 0) {
end = (ziU32)(entry + (((ziU16)entry[4] << 8) + entry[5] + 1) * 10);
entry += 10;
depth = 0;
while ((depth < 2) && (*keys != 0)) {
if ((*keys < 0xeff1) || (0xf010 < *keys)) {
break;
}
end = (ziU32)(entry + (((ziU16)entry[4] << 8) + entry[5] + 1) * 10);
entry += 10;
depth = 0;
while ((depth < 2) && (*keys != 0)) {
if (*keys >= 0xeff1 && *keys <= 0xf010) {
goto checkEntry;
while (1) {
if (*keys == (ziS32)(entry[3] + ((ziU16)entry[2] << 8))) {
if (*keys == (ziS32)(((ziU16)entry[2] << 8) + entry[3])) {
break;
}
entry += (entry[1] + ((ziU16)entry[0] << 8)) * 10 + 10;
entry += (((ziU16)entry[0] << 8) + entry[1]) * 10 + 10;
checkEntry:
if (((ziU32)entry >= end) ||
(*keys == (ziS32)(entry[3] + ((ziU16)entry[2] << 8)))) {
(*keys == (ziS32)(((ziU16)entry[2] << 8) + entry[3]))) {
break;
}
}
if ((ziU32)entry >= end) {
return 0;
}
result = graph + (ziU32)entry[4] * 0x10000 + ((ziU16)entry[5] << 8) +
entry[6];
((zi8DawgCtx*)context)->unk_0x338 =
graph + (ziU32)entry[7] * 0x10000 + ((ziU16)entry[8] << 8) +
entry[9];
if (((zi8DawgCtx*)context)->unk_0x338 == graph) {
((zi8DawgCtx*)context)->unk_0x338 = 0;
}
if ((entry[1] + ((ziU16)entry[0] << 8)) == 0) {
break;
}
end = (ziU32)(entry + (entry[1] + ((ziU16)entry[0] << 8)) * 10 + 10);
entry += 10;
depth++;
keys++;
} else {
return 0;
}
if ((ziU32)entry >= end) {
return 0;
}
result = graph + (ziU32)entry[4] * 0x10000 + (((ziU16)entry[5] << 8) + entry[6]);
((zi8DawgCtx*)context)->unk_0x338 =
graph + (ziU32)entry[7] * 0x10000 + (((ziU16)entry[8] << 8) + entry[9]);
if (((zi8DawgCtx*)context)->unk_0x338 == graph) {
((zi8DawgCtx*)context)->unk_0x338 = 0;
}
if ((((ziU16)entry[0] << 8) + entry[1]) == 0) {
break;
}
end = (ziU32)(entry + (((ziU16)entry[0] << 8) + entry[1]) * 10 + 10);
entry += 10;
depth++;
keys++;
}
return result;

View File

@@ -20,13 +20,12 @@ typedef struct ziChineseEntry {
ziU8 offsetLow[2];
} ziChineseEntry;
ziU8 Zi8GetCandidatesOrCount(ziGetParam*, ziSearchState* ZI_NEED_WORK);
ziU32 Zi8GetCandidatesOrCount(ziGetParam*, ziSearchState* ZI_NEED_WORK);
ziU8 Zi8GetFormatVersion(ziU8 ZI_NEED_WORK);
ziPtr Zi8GetTableAddress(ziU8, ziU8 ZI_NEED_WORK);
ziU16 Zi8Uni2Ord(ziWChar ZI_NEED_WORK);
ziBool Zi8IsWordW(ziWChar* word, ziU8 language ZI_NEED_WORK) {
int count;
int offset;
ziU8 group;
ziU8 remaining;
@@ -35,9 +34,10 @@ ziBool Zi8IsWordW(ziWChar* word, ziU8 language ZI_NEED_WORK) {
ziSearchState search;
ziGetParam request;
ziWChar ordinals[65];
int length;
int count;
int unmatched;
ziChineseEntry* entry;
ziChineseEntry* table;
ziU8* data;
ziU8 formats[8] = {1, 5, 0, 0, 0, 0, 0, 0};
ziU32 savedFormats = ZI_WORK->unk_0x1410;
@@ -54,10 +54,10 @@ ziBool Zi8IsWordW(ziWChar* word, ziU8 language ZI_NEED_WORK) {
return 0;
}
if (language != 1) {
for (length = 0; word[length] != 0; length++) {
if (word[length] >= 0xEFF1 || length == 64) return 0;
for (count = 0; word[count] != 0; count++) {
if (word[count] >= 0xEFF1 || count == 64) return 0;
}
((ziU8*)&search.length)[0] = length;
((ziU8*)&search.length)[0] = count;
((ziU8*)&search.flags)[2] = 1;
((ziU16*)&search.capacity)[0] = 64;
search.word = word;
@@ -67,7 +67,7 @@ ziBool Zi8IsWordW(ziWChar* word, ziU8 language ZI_NEED_WORK) {
request.context = 1;
request.getOptions = 0x81;
request.elements = word;
request.elementCount = length;
request.elementCount = count;
request.currentWord = 0;
request.wordCharCount = 0;
request.candidates = ordinals;
@@ -92,20 +92,22 @@ ziBool Zi8IsWordW(ziWChar* word, ziU8 language ZI_NEED_WORK) {
if (count != 0) return 1;
}
if (language == 1) {
length = 0;
count = 0;
do {
ordinals[length] = Zi8Uni2Ord(word[length], __zi8_work_data);
if (ordinals[length] == 0xFFFF) return 0;
length++;
if (length == 64) return 0;
} while (word[length] != 0);
ordinals[count] = Zi8Uni2Ord(word[count], __zi8_work_data);
if (ordinals[count] == 0xFFFF) return 0;
count++;
if (count == 64) return 0;
} while (word[count] != 0);
{
if (length == 1) return 1;
count = --length;
if (count == 1) return 1;
count--;
ordinals[count] |= 0x8000;
ZI_WORK->cangjieEnabled = Zi8GetFormatVersion(1, __zi8_work_data) & 2;
entry = (ziChineseEntry*)Zi8GetTableAddress(1, 0, __zi8_work_data) + ordinals[0];
data = (ziU8*)Zi8GetTableAddress(1, 1, __zi8_work_data) + ((entry->offsetHigh & 15) << 16 | ((entry->offsetLow[0] << 8) | entry->offsetLow[1]));
table = (ziChineseEntry*)Zi8GetTableAddress(1, 0, __zi8_work_data);
entry = table + ordinals[0];
data = (ziU8*)Zi8GetTableAddress(1, 1, __zi8_work_data);
data += ((entry->offsetHigh & 15) << 16 | ((entry->offsetLow[0] << 8) | entry->offsetLow[1]));
if (ZI_WORK->cangjieEnabled != 0) {
switch (*data & 7) {
case 2:

View File

@@ -0,0 +1,395 @@
# Data d11 attempts
Baseline HEAD 32f358cd, matching origin/main at start.
All four pools contain no strings and are identical.
## zidawg1
- Rename @etb_81330728 -> @34: extabindex relocation at entry for ZiDAWGGetChild identifies the same 8-byte unwind object and 12-byte index record in target and compiler object; address and size unchanged.
- Rename @eti_8133144C -> @35: extabindex relocation at entry for ZiDAWGGetChild identifies the same 8-byte unwind object and 12-byte index record in target and compiler object; address and size unchanged.
- Rename @etb_81330730 -> @85: extabindex relocation at entry for ZiDAWGGetSibling identifies the same 8-byte unwind object and 12-byte index record in target and compiler object; address and size unchanged.
- Rename @eti_81331458 -> @86: extabindex relocation at entry for ZiDAWGGetSibling identifies the same 8-byte unwind object and 12-byte index record in target and compiler object; address and size unchanged.
- Rename @etb_81330738 -> @108: extabindex relocation at entry for ZiDAWGgetCHARattribute identifies the same 8-byte unwind object and 12-byte index record in target and compiler object; address and size unchanged.
- Rename @eti_81331464 -> @109: extabindex relocation at entry for ZiDAWGgetCHARattribute identifies the same 8-byte unwind object and 12-byte index record in target and compiler object; address and size unchanged.
- Rename @etb_81330740 -> @159: extabindex relocation at entry for ZiDAWGGetGraphInfo identifies the same 8-byte unwind object and 12-byte index record in target and compiler object; address and size unchanged.
- Rename @eti_81331470 -> @160: extabindex relocation at entry for ZiDAWGGetGraphInfo identifies the same 8-byte unwind object and 12-byte index record in target and compiler object; address and size unchanged.
- extab: target/source lengths 32/32, byte differences [(24, 56, 64)].
- extabindex: target/source lengths 48/48, byte differences [(19, 12, 4), (43, 24, 8)].
## zi8uwd
- Rename @etb_81330700 -> @69: extabindex relocation at entry for Zi8_81480224 identifies the same 8-byte unwind object and 12-byte index record in target and compiler object; address and size unchanged.
- Rename @eti_81331410 -> @70: extabindex relocation at entry for Zi8_81480224 identifies the same 8-byte unwind object and 12-byte index record in target and compiler object; address and size unchanged.
- Rename @etb_81330708 -> @80: extabindex relocation at entry for Zi8_814803F4 identifies the same 8-byte unwind object and 12-byte index record in target and compiler object; address and size unchanged.
- Rename @eti_8133141C -> @81: extabindex relocation at entry for Zi8_814803F4 identifies the same 8-byte unwind object and 12-byte index record in target and compiler object; address and size unchanged.
- Rename @etb_81330710 -> @88: extabindex relocation at entry for Zi8_8148047C identifies the same 8-byte unwind object and 12-byte index record in target and compiler object; address and size unchanged.
- Rename @eti_81331428 -> @89: extabindex relocation at entry for Zi8_8148047C identifies the same 8-byte unwind object and 12-byte index record in target and compiler object; address and size unchanged.
- Rename @etb_81330718 -> @248: extabindex relocation at entry for Zi8MatchUWDdata identifies the same 8-byte unwind object and 12-byte index record in target and compiler object; address and size unchanged.
- Rename @eti_81331434 -> @249: extabindex relocation at entry for Zi8MatchUWDdata identifies the same 8-byte unwind object and 12-byte index record in target and compiler object; address and size unchanged.
- extab: target/source lengths 32/32, byte differences [(24, 104, 88)].
- extabindex: target/source lengths 48/48, byte differences [(42, 7, 8), (43, 192, 48)].
## zi8pud2
- Rename @etb_813306C0 -> @52: extabindex relocation at entry for ZiGetZHWordSize identifies the same 8-byte unwind object and 12-byte index record in target and compiler object; address and size unchanged.
- Rename @eti_813313B0 -> @53: extabindex relocation at entry for ZiGetZHWordSize identifies the same 8-byte unwind object and 12-byte index record in target and compiler object; address and size unchanged.
- Rename @etb_813306C8 -> @76: extabindex relocation at entry for Zi8CopyZHSpelling identifies the same 8-byte unwind object and 12-byte index record in target and compiler object; address and size unchanged.
- Rename @eti_813313BC -> @77: extabindex relocation at entry for Zi8CopyZHSpelling identifies the same 8-byte unwind object and 12-byte index record in target and compiler object; address and size unchanged.
- Rename @etb_813306D0 -> @86: extabindex relocation at entry for ZADP_Zi8SetPDremoveOpt identifies the same 8-byte unwind object and 12-byte index record in target and compiler object; address and size unchanged.
- Rename @eti_813313C8 -> @87: extabindex relocation at entry for ZADP_Zi8SetPDremoveOpt identifies the same 8-byte unwind object and 12-byte index record in target and compiler object; address and size unchanged.
- Rename @etb_813306D8 -> @215: extabindex relocation at entry for Zi8MatchPUDdata_ZHS identifies the same 8-byte unwind object and 12-byte index record in target and compiler object; address and size unchanged.
- Rename @eti_813313D4 -> @216: extabindex relocation at entry for Zi8MatchPUDdata_ZHS identifies the same 8-byte unwind object and 12-byte index record in target and compiler object; address and size unchanged.
- Rename @etb_813306E0 -> @241: extabindex relocation at entry for Zi8MatchPUDdata identifies the same 8-byte unwind object and 12-byte index record in target and compiler object; address and size unchanged.
- Rename @eti_813313E0 -> @242: extabindex relocation at entry for Zi8MatchPUDdata identifies the same 8-byte unwind object and 12-byte index record in target and compiler object; address and size unchanged.
- Rename @etb_813306E8 -> @255: extabindex relocation at entry for Zi8_8147FD7C identifies the same 8-byte unwind object and 12-byte index record in target and compiler object; address and size unchanged.
- Rename @eti_813313EC -> @256: extabindex relocation at entry for Zi8_8147FD7C identifies the same 8-byte unwind object and 12-byte index record in target and compiler object; address and size unchanged.
- extab: target/source lengths 48/48, byte differences [].
- extabindex: target/source lengths 72/72, byte differences [(43, 136, 120)].
## ziswordw
- Rename @etb_81330760 -> @127: extabindex relocation at entry for Zi8IsWordW identifies the same 8-byte unwind object and 12-byte index record in target and compiler object; address and size unchanged.
- Rename @eti_813314A0 -> @128: extabindex relocation at entry for Zi8IsWordW identifies the same 8-byte unwind object and 12-byte index record in target and compiler object; address and size unchanged.
- Rename @etb_81330768 -> @174: extabindex relocation at entry for Zi8ConvertUC2UserKey identifies the same 8-byte unwind object and 12-byte index record in target and compiler object; address and size unchanged.
- Rename @eti_813314AC -> @175: extabindex relocation at entry for Zi8ConvertUC2UserKey identifies the same 8-byte unwind object and 12-byte index record in target and compiler object; address and size unchanged.
- extab: target/source lengths 16/16, byte differences [(0, 48, 40)].
- extabindex: target/source lengths 24/24, byte differences [(7, 128, 136)].
- .sdata2: target/source lengths 8/8, byte differences [].
- ZiDAWGGetChild attempt 1, widen decoded header to match explicit narrowing: instruction-exact 2, identical non-text bytes 0, raw byte matches 76, target/source function sizes (272, 260). Reverted.
- ZiDAWGGetChild attempt 2, combine encoded displacement before assigning it: instruction-exact 2, identical non-text bytes 0, raw byte matches 77, target/source function sizes (272, 272). Reverted.
- ZiDAWGGetChild attempt 3, combine short displacement in one assignment: instruction-exact 2, identical non-text bytes 0, raw byte matches 77, target/source function sizes (272, 272). Reverted.
- ZiDAWGGetSibling attempt 1, decode header in full word temporary: instruction-exact 2, identical non-text bytes 0, raw byte matches 76, target/source function sizes (524, 488). Reverted.
- ZiDAWGGetSibling attempt 2, invert long-offset branch to target direction: instruction-exact 2, identical non-text bytes 0, raw byte matches 77, target/source function sizes (524, 516). Reverted.
- ZiDAWGGetSibling attempt 3, retain 16-bit mask in long sibling displacement: instruction-exact 2, identical non-text bytes 0, raw byte matches 77, target/source function sizes (524, 520). Reverted.
- ZiDAWGgetCHARattribute attempt 1, decode low attribute bytes as one value: instruction-exact 2, identical non-text bytes 0, raw byte matches 77, target/source function sizes (240, 240). Reverted.
- ZiDAWGgetCHARattribute attempt 2, widen key during decode: instruction-exact 2, identical non-text bytes 0, raw byte matches 76, target/source function sizes (240, 212). Reverted.
- ZiDAWGgetCHARattribute attempt 3, declare output before decoded key: instruction-exact 2, identical non-text bytes 0, raw byte matches 77, target/source function sizes (240, 240). Reverted.
- ZiDAWGGetGraphInfo attempt 1, keep two header predicates together: instruction-exact 2, identical non-text bytes 0, raw byte matches 77, target/source function sizes (536, 520). Reverted.
- ZiDAWGGetGraphInfo attempt 2, decode entry header without persistent pair local: instruction-exact 2, identical non-text bytes 32, raw byte matches 78, target/source function sizes (536, 520). Selected.
- ZiDAWGGetGraphInfo attempt 3, widen depth used as loop counter: instruction-exact 2, identical non-text bytes 0, raw byte matches 77, target/source function sizes (536, 516). Reverted.
- Zi8_81480224 attempt 1, use separate insertion index instead of recycling length: instruction-exact 2, identical non-text bytes 0, raw byte matches 77, target/source function sizes (464, 464). Reverted.
- Zi8_81480224 attempt 2, compare candidates through incrementing text cursors: instruction-exact 2, identical non-text bytes 0, raw byte matches 77, target/source function sizes (464, 464). Reverted.
- Zi8_81480224 attempt 3, declare candidate length after list pointers: instruction-exact 2, identical non-text bytes 0, raw byte matches 77, target/source function sizes (464, 464). Reverted.
- Zi8MatchUWDdata attempt 1, use 32-bit return temporary for converted entry language: instruction-exact 2, identical non-text bytes 0, raw byte matches 77, target/source function sizes (1984, 2100). Reverted.
- Zi8MatchUWDdata attempt 2, keep returned entry length in integer temporary: instruction-exact 2, identical non-text bytes 0, raw byte matches 77, target/source function sizes (1984, 2096). Reverted.
- Zi8MatchUWDdata attempt 3, use dictionary base fields directly for initial cursor: instruction-exact 2, identical non-text bytes 0, raw byte matches 77, target/source function sizes (1984, 2096). Reverted.
- ZADP_Zi8SetPDremoveOpt attempt 1, return previous option as a full word: instruction-exact 4, identical non-text bytes 48, raw byte matches 119, target/source function sizes (84, 84). Reverted.
- ZADP_Zi8SetPDremoveOpt attempt 2, retain work pointer explicitly before previous option: build failed, reverted. lib\zi8pud2.c # ------------------------------------------------------ # 54: ziWorkData* work = ZI_WORK; # Error: ^^^^^^^^^^ # (10140) undefined identifier 'ziWorkData' # Too many errors printed, aborting program User break, cancelled... ninja: build stopped: subcommand failed.
- ZADP_Zi8SetPDremoveOpt attempt 3, scope previous option initialization at declaration: instruction-exact 4, identical non-text bytes 48, raw byte matches 119, target/source function sizes (84, 84). Reverted.
- Zi8MatchPUDdata_ZHS attempt 1, replace compound section-loop condition with explicit language break: instruction-exact 4, identical non-text bytes 48, raw byte matches 119, target/source function sizes (1416, 1400). Reverted.
- Zi8MatchPUDdata_ZHS attempt 2, let byte overflow implement Chinese doubled-length mask: instruction-exact 4, identical non-text bytes 48, raw byte matches 119, target/source function sizes (1416, 1392). Reverted.
- Zi8MatchPUDdata_ZHS attempt 3, keep Chinese entry length in signed integer: instruction-exact 4, identical non-text bytes 48, raw byte matches 119, target/source function sizes (1416, 1400). Reverted.
- Zi8MatchPUDdata attempt 1, use byte result matching wrapper return test: instruction-exact 4, identical non-text bytes 48, raw byte matches 118, target/source function sizes (200, 196). Reverted.
- Zi8MatchPUDdata attempt 2, initialize result at call inside explicit loop block: instruction-exact 4, identical non-text bytes 0, raw byte matches 116, target/source function sizes (200, 228). Reverted.
- Zi8MatchPUDdata attempt 3, scope loop flag through explicit zero comparison: instruction-exact 4, identical non-text bytes 48, raw byte matches 119, target/source function sizes (200, 200). Reverted.
- Zi8IsWordW attempt 1, initialize search before saving formats and count: instruction-exact 1, identical non-text bytes 8, raw byte matches 46, target/source function sizes (1664, 1672). Reverted.
- Zi8IsWordW attempt 2, invert format count branch to target order: instruction-exact 1, identical non-text bytes 8, raw byte matches 46, target/source function sizes (1664, 1672). Reverted.
- Zi8IsWordW attempt 3, keep candidate count as unsigned word: instruction-exact 1, identical non-text bytes 8, raw byte matches 46, target/source function sizes (1664, 1672). Reverted.
Unwind-name experiment reverted in full: source-generated @ numbers changed extabindex fuzzy pairing but no matched_data count increased; original extraction names are retained. No symbol extents or addresses changed.
- Zi8MatchPUDdata_ZHS followup, preserve target 16-bit narrowing for section count and offset bytes: instruction-exact 4, identical non-text bytes 120, raw byte matches 120, target/source sizes (1416, 1416). Selected.
- ZiDAWGGetSibling followup, combine target branch direction and 16-bit sibling displacement narrowing: instruction-exact 2, identical non-text bytes 32, raw byte matches 78, target/source sizes (524, 520). Reverted.
- ZiDAWGGetGraphInfo followup, narrow entry size and key words as shown in target instruction sequence: instruction-exact 2, identical non-text bytes 32, raw byte matches 78, target/source sizes (536, 520). Reverted.
- ZADP_Zi8SetPDremoveOpt followup, explicit typed work pointer using actual SDK work structure: instruction-exact 4, identical non-text bytes 0, raw byte matches 118, target/source sizes (84, 96). Reverted.
- Zi8IsWordW followup: correct local Zi8GetCandidatesOrCount return prototype from ziU8 to ziU32. Definition and both declarations in zi8getc2.c return ziU32; target caller moves r3 into r29 without byte narrowing. This changes only ziswordw output.
- Zi8IsWordW attempt 4, initialize Chinese decoding locals in target order: instruction-exact 1, identical non-text bytes 8, raw byte matches 46, target/source sizes (1664, 1704). Reverted.
- Zi8IsWordW attempt 5, zero search aggregate after saving original formats: instruction-exact 1, identical non-text bytes 8, raw byte matches 46, target/source sizes (1664, 1648). Reverted.
- Zi8IsWordW attempt 6, match request assignments to target word pointer before capacity: instruction-exact 1, identical non-text bytes 8, raw byte matches 46, target/source sizes (1664, 1668). Reverted.
- Zi8IsWordW attempt 7, use typed byte-pair fields for Chinese decoded offset: instruction-exact 1, identical non-text bytes 8, raw byte matches 46, target/source sizes (1664, 1676). Reverted.
- Zi8IsWordW attempt 8, combined target initialization and request order: instruction-exact 1, identical non-text bytes 8, raw byte matches 46, target/source sizes (1664, 1684). Reverted.
- ZiDAWGGetGraphInfo further followup, return zero on unsupported key as target direct-return block proves: instruction-exact 2, identical non-text bytes 32, raw byte matches 78, target/source sizes (536, 528). Reverted.
- ZiDAWGGetGraphInfo further followup, match top-tested child-search loop with explicit extent exit: instruction-exact 2, identical non-text bytes 32, raw byte matches 77, target/source sizes (536, 492). Reverted.
- ZiDAWGGetSibling further followup, explicit target halfword narrowing at header-table load: instruction-exact 2, identical non-text bytes 32, raw byte matches 79, target/source sizes (524, 524). Reverted.
- Zi8MatchUWDdata further followup, advance typed result text cursor once before conversion loop: instruction-exact 2, identical non-text bytes 0, raw byte matches 77, target/source sizes (1984, 2112). Reverted.
- ZiDAWGGetSibling halfword-load followup retained for combined validation: source size now 524 equals target; target lhzx-to-r0 then clrlwi-to-saved-register proves explicit halfword narrowing, instruction-exact counts stay 2/6. One extabindex record now has the exact length.
- ZiDAWGGetGraphInfo combined followup, preserve invalid-key exit and decode graph offset in byte order: instruction-exact 2, identical non-text bytes 32, raw byte matches 79, target/source sizes (536, 528). Reverted.
- ZiDAWGGetGraphInfo combined followup, group graph child-count header rejects in one condition: instruction-exact 2, identical non-text bytes 32, raw byte matches 79, target/source sizes (536, 528). Reverted.
- ZiDAWGGetGraphInfo combined followup, split key range rejects matching direct target branches: instruction-exact 2, identical non-text bytes 80, raw byte matches 80, target/source sizes (536, 536). Selected.
- Zi8MatchUWDdata remaining-data followup, reuse language parameter for early and final popped entries as target does: instruction-exact 2, identical non-text bytes 0, raw byte matches 77, target/source sizes (1984, 2092). Reverted.
- Zi8MatchUWDdata remaining-data followup, scope continuation result independently: instruction-exact 2, identical non-text bytes 0, raw byte matches 76, target/source sizes (1984, 2108). Reverted.
- Zi8MatchUWDdata remaining-data followup, combine independent continuation result and reused language: instruction-exact 2, identical non-text bytes 0, raw byte matches 76, target/source sizes (1984, 2104). Reverted.
- Zi8IsWordW remaining-data followup, reorder genuine offset local after ordinal length: instruction-exact 1, identical non-text bytes 8, raw byte matches 46, target/source sizes (1664, 1668). Reverted.
- Count-reuse experiment initially failed to build because the scripted identifier change also changed search.length; restored, corrected the transformation to exclude member names, and retried.
- Zi8IsWordW remaining-data followup, reuse count for length and candidate result matching target r29 lifetime: instruction-exact 1, identical non-text bytes 8, raw byte matches 46, target/source sizes (1664, 1652). Reverted.
- Zi8IsWordW remaining-data followup, fuse terminal Chinese length decrement into single-length test: instruction-exact 1, identical non-text bytes 8, raw byte matches 46, target/source sizes (1664, 1652). Reverted.
- Zi8IsWordW remaining-data followup, reorder genuine offset local after ordinal length: instruction-exact 1, identical non-text bytes 8, raw byte matches 46, target/source sizes (1664, 1668). Reverted.
- Zi8IsWordW final followup, split table base lookup and encoded entry offset: instruction-exact 1, identical non-text bytes 8, raw byte matches 46, target/source sizes (1664, 1680). Reverted.
- Zi8IsWordW final followup, reuse count and split table base lookup: instruction-exact 1, identical non-text bytes 32, raw byte matches 47, target/source sizes (1664, 1664). Selected.
- Zi8IsWordW final followup, declare decoded offset as unsigned word with reused count: instruction-exact 1, identical non-text bytes 8, raw byte matches 46, target/source sizes (1664, 1652). Reverted.
- Zi8IsWordW final followup, keep count conversion result and selector in distinct scopes: instruction-exact 1, identical non-text bytes 8, raw byte matches 46, target/source sizes (1664, 1680). Reverted.
- Zi8IsWordW final followup, initialize groups and entry words with reused count: instruction-exact 1, identical non-text bytes 8, raw byte matches 46, target/source sizes (1664, 1676). Reverted.
- Zi8IsWordW selector followup, explicit decoded format selector before switch: instruction-exact 1, identical non-text bytes 8, raw byte matches 46, target/source sizes (1664, 1672). Reverted.
- Zi8IsWordW selector followup, initialize decoded format displacement to target default: instruction-exact 1, identical non-text bytes 8, raw byte matches 46, target/source sizes (1664, 1672). Reverted.
- Zi8IsWordW selector followup, decode selector into unsigned shift variable: instruction-exact 1, identical non-text bytes 8, raw byte matches 46, target/source sizes (1664, 1672). Reverted.
- Zi8IsWordW selector followup, factor selector size defaults before switch: instruction-exact 1, identical non-text bytes 8, raw byte matches 46, target/source sizes (1664, 1660). Reverted.
- Zi8MatchUWDdata loop followup, keep both prefix scan induction variables in the loop update: instruction-exact 2, identical non-text bytes 0, raw byte matches 77, target/source sizes (1984, 2100). Reverted.
- Zi8MatchUWDdata loop followup, initialize ring scan cursor in its own loop: instruction-exact 2, identical non-text bytes 0, raw byte matches 77, target/source sizes (1984, 2096). Reverted.
- Zi8MatchUWDdata loop followup, combine prefix and cursor scan loop induction variables: instruction-exact 2, identical non-text bytes 0, raw byte matches 77, target/source sizes (1984, 2100). Reverted.
- Zi8MatchUWDdata loop followup, use preincrement prefix counter after character test: instruction-exact 2, identical non-text bytes 0, raw byte matches 77, target/source sizes (1984, 2096). Reverted.
## Coverage audit and remaining data classification
- ZADP_Zi8SetPDremoveOpt: all three initial distinct attempts logged, plus followups where indicated. Initial objdiff 98.57143%, instruction-exact count retained.
- Zi8MatchPUDdata_ZHS: all three initial distinct attempts logged, plus followups where indicated. Initial objdiff 72.59322%, instruction-exact count retained.
- Zi8MatchPUDdata: all three initial distinct attempts logged, plus followups where indicated. Initial objdiff 99.1%, instruction-exact count retained.
- Zi8_81480224: all three initial distinct attempts logged, plus followups where indicated. Initial objdiff 99.22414%, instruction-exact count retained.
- Zi8MatchUWDdata: all three initial distinct attempts logged, plus followups where indicated. Initial objdiff 70.245964%, instruction-exact count retained.
- ZiDAWGGetChild: all three initial distinct attempts logged, plus followups where indicated. Initial objdiff 93.60294%, instruction-exact count retained.
- ZiDAWGGetSibling: all three initial distinct attempts logged, plus followups where indicated. Initial objdiff 86.854965%, instruction-exact count retained.
- ZiDAWGgetCHARattribute: all three initial distinct attempts logged, plus followups where indicated. Initial objdiff 95.5%, instruction-exact count retained.
- ZiDAWGGetGraphInfo: all three initial distinct attempts logged, plus followups where indicated. Initial objdiff 81.83582%, instruction-exact count retained.
- Zi8IsWordW: all three initial distinct attempts logged, plus followups where indicated. Initial objdiff 83.33654%, instruction-exact count retained.
- zidawg1: extab and extabindex bytes now identical, including all four owned exception records. No metadata renames or extent changes retained.
- zi8pud2: extab and extabindex bytes now identical; explicit 16-bit section-count/offset decoding follows four target clrlwi instructions. No metadata changes.
- zi8uwd: no literal/global data. Residual extab record for Zi8MatchUWDdata saves r19-r31 in target, r21-r31 in source; extabindex length is target 1984 versus source 2096. These are real code-generation differences, not name/extent errors. Other three extab records and their lengths match.
- ziswordw: .sdata2 and extabindex bytes identical; residual extab for Zi8IsWordW saves r26-r31 in target, r27-r31 in source. Zi8ConvertUC2UserKey unwind bytes and instruction-exact function remain unchanged. The residual is code register allocation, not a data initializer or symbol-name mismatch.
- No symbol-size adjustments, forced sections, alignment objects, volatile casts, or assembly added. All retained code is in owned units.
## Final per-symbol data audit
- zidawg1
- @etb_81330728, extab+0x0, size 8, ZiDAWGGetChild: identical bytes; relocations pair by owning function and unwind entry.
- @etb_81330730, extab+0x8, size 8, ZiDAWGGetSibling: identical bytes; relocations pair by owning function and unwind entry.
- @etb_81330738, extab+0x10, size 8, ZiDAWGgetCHARattribute: identical bytes; relocations pair by owning function and unwind entry.
- @etb_81330740, extab+0x18, size 8, ZiDAWGGetGraphInfo: identical bytes; relocations pair by owning function and unwind entry.
- @eti_8133144C, extabindex+0x0, size 12, ZiDAWGGetChild: identical bytes; relocations pair by owning function and unwind entry.
- @eti_81331458, extabindex+0xc, size 12, ZiDAWGGetSibling: identical bytes; relocations pair by owning function and unwind entry.
- @eti_81331464, extabindex+0x18, size 12, ZiDAWGgetCHARattribute: identical bytes; relocations pair by owning function and unwind entry.
- @eti_81331470, extabindex+0x24, size 12, ZiDAWGGetGraphInfo: identical bytes; relocations pair by owning function and unwind entry.
- zi8uwd
- @etb_81330700, extab+0x0, size 8, Zi8_81480224: identical bytes; relocations pair by owning function and unwind entry.
- @etb_81330708, extab+0x8, size 8, Zi8_814803F4: identical bytes; relocations pair by owning function and unwind entry.
- @etb_81330710, extab+0x10, size 8, Zi8_8148047C: identical bytes; relocations pair by owning function and unwind entry.
- @etb_81330718, extab+0x18, size 8, Zi8MatchUWDdata: real code-derived metadata differences [('0x0', '0x68', '0x58')].
- @eti_81331410, extabindex+0x0, size 12, Zi8_81480224: identical bytes; relocations pair by owning function and unwind entry.
- @eti_8133141C, extabindex+0xc, size 12, Zi8_814803F4: identical bytes; relocations pair by owning function and unwind entry.
- @eti_81331428, extabindex+0x18, size 12, Zi8_8148047C: identical bytes; relocations pair by owning function and unwind entry.
- @eti_81331434, extabindex+0x24, size 12, Zi8MatchUWDdata: real code-derived metadata differences [('0x6', '0x7', '0x8'), ('0x7', '0xc0', '0x30')].
- zi8pud2
- @etb_813306C0, extab+0x0, size 8, ZiGetZHWordSize: identical bytes; relocations pair by owning function and unwind entry.
- @etb_813306C8, extab+0x8, size 8, Zi8CopyZHSpelling: identical bytes; relocations pair by owning function and unwind entry.
- @etb_813306D0, extab+0x10, size 8, ZADP_Zi8SetPDremoveOpt: identical bytes; relocations pair by owning function and unwind entry.
- @etb_813306D8, extab+0x18, size 8, Zi8MatchPUDdata_ZHS: identical bytes; relocations pair by owning function and unwind entry.
- @etb_813306E0, extab+0x20, size 8, Zi8MatchPUDdata: identical bytes; relocations pair by owning function and unwind entry.
- @etb_813306E8, extab+0x28, size 8, Zi8_8147FD7C: identical bytes; relocations pair by owning function and unwind entry.
- @eti_813313B0, extabindex+0x0, size 12, ZiGetZHWordSize: identical bytes; relocations pair by owning function and unwind entry.
- @eti_813313BC, extabindex+0xc, size 12, Zi8CopyZHSpelling: identical bytes; relocations pair by owning function and unwind entry.
- @eti_813313C8, extabindex+0x18, size 12, ZADP_Zi8SetPDremoveOpt: identical bytes; relocations pair by owning function and unwind entry.
- @eti_813313D4, extabindex+0x24, size 12, Zi8MatchPUDdata_ZHS: identical bytes; relocations pair by owning function and unwind entry.
- @eti_813313E0, extabindex+0x30, size 12, Zi8MatchPUDdata: identical bytes; relocations pair by owning function and unwind entry.
- @eti_813313EC, extabindex+0x3c, size 12, Zi8_8147FD7C: identical bytes; relocations pair by owning function and unwind entry.
- ziswordw
- @etb_81330760, extab+0x0, size 8, Zi8IsWordW: real code-derived metadata differences [('0x0', '0x30', '0x28')].
- @etb_81330768, extab+0x8, size 8, Zi8ConvertUC2UserKey: identical bytes; relocations pair by owning function and unwind entry.
- @eti_813314A0, extabindex+0x0, size 12, Zi8IsWordW: identical bytes; relocations pair by owning function and unwind entry.
- @eti_813314AC, extabindex+0xc, size 12, Zi8ConvertUC2UserKey: identical bytes; relocations pair by owning function and unwind entry.
- lbl_81695018, .sdata2+0x0, size 1, : identical bytes; relocations pair by owning function and unwind entry.
- lbl_81695019, .sdata2+0x1, size 1, : identical bytes; relocations pair by owning function and unwind entry.
- lbl_8169501A, .sdata2+0x2, size 1, : identical bytes; relocations pair by owning function and unwind entry.
- lbl_8169501B, .sdata2+0x3, size 1, : identical bytes; relocations pair by owning function and unwind entry.
- lbl_8169501C, .sdata2+0x4, size 1, : identical bytes; relocations pair by owning function and unwind entry.
- lbl_8169501D, .sdata2+0x5, size 1, : identical bytes; relocations pair by owning function and unwind entry.
- lbl_8169501E, .sdata2+0x6, size 1, : identical bytes; relocations pair by owning function and unwind entry.
- lbl_8169501F, .sdata2+0x7, size 1, : identical bytes; relocations pair by owning function and unwind entry.
## Final clean full gate
```
full build: ok
main.dol sha1: 26116613f624061ba99c8d1a299aaa6efa85670d
[libs/RVLMiddleware/eZiText/src/clib/zidawg1] pool: IDENTICAL
[libs/RVLMiddleware/eZiText/src/clib/zidawg1] objdiff: code 92/1664 data 80/80 functions 2/6 fuzzy 87.7019 linked code 0
[libs/RVLMiddleware/eZiText/src/clib/zidawg1] instruction-exact functions: 2/6
[libs/RVLMiddleware/eZiText/src/clib/zidawg1] section .text size 1664 match 87.70192
[libs/RVLMiddleware/eZiText/src/clib/zidawg1] section extab size 32 match 100.0
[libs/RVLMiddleware/eZiText/src/clib/zidawg1] section extabindex size 48 match 100.0
[libs/RVLMiddleware/eZiText/src/clib/zidawg1] below 100: ZiDAWGGetChild 93.60294
[libs/RVLMiddleware/eZiText/src/clib/zidawg1] below 100: ZiDAWGGetSibling 86.51145
[libs/RVLMiddleware/eZiText/src/clib/zidawg1] below 100: ZiDAWGgetCHARattribute 95.5
[libs/RVLMiddleware/eZiText/src/clib/zidawg1] below 100: ZiDAWGGetGraphInfo 80.268654
[libs/RVLMiddleware/eZiText/src/clib/zidawg1] baseline: code 92/1664 data None functions 2 fuzzy 88.3149
[libs/RVLMiddleware/eZiText/src/clib/zi8uwd] pool: IDENTICAL
[libs/RVLMiddleware/eZiText/src/clib/zi8uwd] objdiff: code 208/2656 data None/80 functions 2/4 fuzzy 77.6386 linked code 0
[libs/RVLMiddleware/eZiText/src/clib/zi8uwd] instruction-exact functions: 2/4
[libs/RVLMiddleware/eZiText/src/clib/zi8uwd] section .text size 2656 match 77.63856
[libs/RVLMiddleware/eZiText/src/clib/zi8uwd] section extab size 32 match 96.875
[libs/RVLMiddleware/eZiText/src/clib/zi8uwd] section extabindex size 48 match 95.83333
[libs/RVLMiddleware/eZiText/src/clib/zi8uwd] below 100: Zi8_81480224 99.22414
[libs/RVLMiddleware/eZiText/src/clib/zi8uwd] below 100: Zi8MatchUWDdata 70.245964
[libs/RVLMiddleware/eZiText/src/clib/zi8uwd] baseline: code 208/2656 data None functions 2 fuzzy 77.6386
[libs/RVLMiddleware/eZiText/src/clib/zi8pud2] pool: IDENTICAL
[libs/RVLMiddleware/eZiText/src/clib/zi8pud2] objdiff: code 436/2136 data 120/120 functions 4/7 fuzzy 81.4288 linked code 0
[libs/RVLMiddleware/eZiText/src/clib/zi8pud2] instruction-exact functions: 4/7
[libs/RVLMiddleware/eZiText/src/clib/zi8pud2] section .text size 2136 match 81.42884
[libs/RVLMiddleware/eZiText/src/clib/zi8pud2] section extab size 48 match 100.0
[libs/RVLMiddleware/eZiText/src/clib/zi8pud2] section extabindex size 72 match 100.0
[libs/RVLMiddleware/eZiText/src/clib/zi8pud2] below 100: ZADP_Zi8SetPDremoveOpt 98.57143
[libs/RVLMiddleware/eZiText/src/clib/zi8pud2] below 100: Zi8MatchPUDdata_ZHS 72.19774
[libs/RVLMiddleware/eZiText/src/clib/zi8pud2] below 100: Zi8MatchPUDdata 99.1
[libs/RVLMiddleware/eZiText/src/clib/zi8pud2] baseline: code 436/2136 data 48 functions 4 fuzzy 81.6910
[libs/RVLMiddleware/eZiText/src/clib/ziswordw] pool: IDENTICAL
[libs/RVLMiddleware/eZiText/src/clib/ziswordw] objdiff: code 364/2028 data 32/48 functions 1/2 fuzzy 88.2229 linked code 0
[libs/RVLMiddleware/eZiText/src/clib/ziswordw] instruction-exact functions: 1/2
[libs/RVLMiddleware/eZiText/src/clib/ziswordw] section .sdata2 size 8 match 100.0
[libs/RVLMiddleware/eZiText/src/clib/ziswordw] section .text size 2028 match 88.22288
[libs/RVLMiddleware/eZiText/src/clib/ziswordw] section extab size 16 match 93.75
[libs/RVLMiddleware/eZiText/src/clib/ziswordw] section extabindex size 24 match 100.0
[libs/RVLMiddleware/eZiText/src/clib/ziswordw] below 100: Zi8IsWordW 85.64664
[libs/RVLMiddleware/eZiText/src/clib/ziswordw] baseline: code 364/2028 data 8 functions 1 fuzzy 86.3274
regressions vs baseline: 0
global matched_code_percent: 88.57407 -> 88.57407
global fuzzy_match_percent: 99.45531 -> 99.45609
global complete_code_percent: 63.07103 -> 63.07103
global matched_data_percent: 97.73032 -> 97.73993
forbidden patterns added (net, per file): 0
readability warnings (net, per file; must be 0 in the final result): 0
GATE PASS
```
Data lane incomplete for zi8uwd and ziswordw. All remaining non-exact code functions have at least three logged source attempts. No instruction-exact function count dropped.
## Orchestrator rejection and resumed worker
Restored zidawg1.c and zi8pud2.c from current origin/main. Previous unwind-only changes are rejected: they lower function fuzzy scores, and redundant load masks are not accepted. Kept ziswordw.c. Future candidates must preserve every owned function fuzzy score and improve real target control flow/register use.
Live origin baseline 2f0f5a44c72cb84e23732e09fc8e75487c788f76 built in this worker tree, then owned source restored and rebuilt. Restored full gate passed with correct DOL hash. Function-by-function comparison:
```
zi8pud2 ZiIsPhoneticChar: 100.0 -> 100.0
zi8pud2 ZiGetZHWordSize: 100.0 -> 100.0
zi8pud2 Zi8CopyZHSpelling: 100.0 -> 100.0
zi8pud2 ZADP_Zi8SetPDremoveOpt: 98.57143 -> 98.57143
zi8pud2 Zi8MatchPUDdata_ZHS: 72.59322 -> 72.59322
zi8pud2 Zi8MatchPUDdata: 99.1 -> 99.1
zi8pud2 Zi8_8147FD7C: 100.0 -> 100.0
zi8uwd Zi8_81480224: 99.22414 -> 99.22414
zi8uwd Zi8_814803F4: 100.0 -> 100.0
zi8uwd Zi8_8148047C: 100.0 -> 100.0
zi8uwd Zi8MatchUWDdata: 70.245964 -> 70.245964
zidawg1 ZiDAWGGetChild: 93.60294 -> 93.60294
zidawg1 ZiDAWGGetSibling: 86.854965 -> 86.854965
zidawg1 ZiDAWGgetEOWattribute: 100.0 -> 100.0
zidawg1 ZiDAWGgetCHARattribute: 95.5 -> 95.5
zidawg1 ZiDAWGGetGraph: 100.0 -> 100.0
zidawg1 ZiDAWGGetGraphInfo: 81.83582 -> 81.83582
ziswordw Zi8IsWordW: 83.33654 -> 85.64664
ziswordw Zi8ConvertUC2UserKey: 100.0 -> 100.0
FUZZY REGRESSIONS: 0
```
- Resume ZiDAWGGetSibling, separate original-node base from encoded-offset cursor, target 81480F6C/81480F88 add original r28: objdiff 86.854965 -> 88.59542; data 0 -> 0; instruction-exact 2 -> 2; target/source sizes (524, 520); source unwind 1808000000000000200800000000000028080000000000004008000000000000; fuzzy regressions []; SELECTED.
- Resume ZiDAWGGetSibling, decode header from incoming cursor before changing it: objdiff 88.59542 -> 88.63359; data 0 -> 0; instruction-exact 2 -> 2; target/source sizes (524, 520); source unwind 1808000000000000200800000000000028080000000000004008000000000000; fuzzy regressions []; SELECTED.
- Resume ZiDAWGGetSibling, emit direct no-sibling return proven by 81480ED4/81480ED8: objdiff 88.63359 -> 88.938934; data 0 -> 0; instruction-exact 2 -> 2; target/source sizes (524, 520); source unwind 1808000000000000200800000000000028080000000000004008000000000000; fuzzy regressions []; SELECTED.
- Resume ZiDAWGGetSibling, invert child-offset branch to target long-first control flow: objdiff 88.938934 -> 88.99236; data 0 -> 0; instruction-exact 2 -> 2; target/source sizes (524, 520); source unwind 1808000000000000200800000000000028080000000000004008000000000000; fuzzy regressions []; SELECTED.
- Resume ZiDAWGGetSibling, return decoded sibling directly at target 81480F90/81480F94: objdiff 88.99236 -> 89.51145; data 0 -> 0; instruction-exact 2 -> 2; target/source sizes (524, 524); source unwind 1808000000000000200800000000000028080000000000004008000000000000; fuzzy regressions []; SELECTED.
- Resume ZiDAWGGetSibling, group original-node plus low displacement byte before encoded high displacement: objdiff 89.51145 -> 87.92367; data 0 -> 0; instruction-exact 2 -> 2; target/source sizes (524, 524); source unwind 1808000000000000200800000000000028080000000000004008000000000000; fuzzy regressions []; reverted.
- Resume ZiDAWGGetSibling, decode short displacement through its two byte weights: objdiff 89.51145 -> 91.16031; data 0 -> 0; instruction-exact 2 -> 2; target/source sizes (524, 524); source unwind 1808000000000000200800000000000028080000000000004008000000000000; fuzzy regressions []; SELECTED.
- Resume ZiDAWGGetGraphInfo, avoid persistent decoded header temporary, target first comparisons use r0: objdiff 81.83582 -> 81.87313; data 0 -> 32; instruction-exact 2 -> 2; target/source sizes (536, 520); source unwind 1808000000000000200800000000000028080000000000003808000000000000; fuzzy regressions []; SELECTED.
- Resume ZiDAWGGetGraphInfo, group empty-root header checks matching branch to 81481240: objdiff 81.87313 -> 85.00746; data 32 -> 32; instruction-exact 2 -> 2; target/source sizes (536, 520); source unwind 1808000000000000200800000000000028080000000000003808000000000000; fuzzy regressions []; SELECTED.
- Resume ZiDAWGGetGraphInfo, validate key range with shared zero-return else at 81481308: objdiff 85.00746 -> 87.32089; data 32 -> 32; instruction-exact 2 -> 2; target/source sizes (536, 532); source unwind 1808000000000000200800000000000028080000000000003808000000000000; fuzzy regressions []; SELECTED.
- Resume ZiDAWGGetGraphInfo, top-test child search with target extent check and common key comparison: objdiff 87.32089 -> 85.08209; data 32 -> 32; instruction-exact 2 -> 2; target/source sizes (536, 504); source unwind 1808000000000000200800000000000028080000000000003808000000000000; fuzzy regressions []; reverted.
- Resume ZiDAWGGetGraphInfo, decode big-endian header high byte before low byte: objdiff 87.32089 -> 95.19403; data 32 -> 32; instruction-exact 2 -> 2; target/source sizes (536, 532); source unwind 1808000000000000200800000000000028080000000000003808000000000000; fuzzy regressions []; SELECTED.
- Resume ZiDAWGGetGraphInfo, group 24-bit offsets as high part plus trailing two-byte value: objdiff 95.19403 -> 98.43284; data 32 -> 32; instruction-exact 2 -> 2; target/source sizes (536, 532); source unwind 1808000000000000200800000000000028080000000000003808000000000000; fuzzy regressions []; SELECTED.
- Resume ZiDAWGGetGraphInfo, tie depth and key induction variables to bounded traversal loop: objdiff 98.43284 -> 97.68657; data 32 -> 48; instruction-exact 2 -> 2; target/source sizes (536, 536); source unwind 1808000000000000200800000000000028080000000000004008000000000000; fuzzy regressions []; reverted.
- Resume ZiDAWGGetGraphInfo, treat returned graph address as unsigned value: objdiff 98.43284 -> 98.43284; data 32 -> 32; instruction-exact 2 -> 2; target/source sizes (536, 532); source unwind 1808000000000000200800000000000028080000000000003808000000000000; fuzzy regressions []; reverted.
- Resume ZiDAWGGetGraphInfo, check entry bounds before the first dereference, target 81481298 branches to 814812DC: objdiff 98.43284 -> 99.17911; data 32 -> 80; instruction-exact 2 -> 2; target/source sizes (536, 536); source unwind 1808000000000000200800000000000028080000000000003808000000000000; fuzzy regressions []; SELECTED.
- Resume ZiDAWGGetGraphInfo, use actual graph/end/result byte pointers consistent with caller zi8dawg.c: objdiff 99.17911 -> 99.17911; data 80 -> 80; instruction-exact 2 -> 2; target/source sizes (536, 536); source unwind 1808000000000000200800000000000028080000000000003808000000000000; fuzzy regressions []; reverted.
- Removed redundant outer graph-search scope after root guard. Object metrics unchanged: sibling 91.16031%, graph info 99.17911%, extab/extabindex 100%; exact 2/6 retained.
- Target proof for graph-search invalid key: branches at 81481288 and 81481294 both reach li r3,0 at 81481308 and return via 814813E4; the former break returning prior result was wrong. New shared else models that control flow.
- Current graph info ctxdiff 134/134 instructions, 20 differences remain, principally callee register names plus endpoint arithmetic scheduling. Prologue saves r25-r31, exactly the target range.
- Resume Zi8MatchPUDdata_ZHS, let doubled byte length wrap naturally without redundant pre-mask: objdiff 72.59322 -> 73.46045; data 48 -> 48; instruction-exact 4 -> 4; target/source sizes (1416, 1392); source unwind 180800000000000010080000000000001008000000000000680800000000000018080000000000000008000000000000; fuzzy regressions []; SELECTED.
- Resume Zi8MatchPUDdata_ZHS, advance one payload cursor through length/priority/text as target r29: objdiff 73.46045 -> 77.74011; data 48 -> 48; instruction-exact 4 -> 4; target/source sizes (1416, 1372); source unwind 180800000000000010080000000000001008000000000000680800000000000018080000000000000008000000000000; fuzzy regressions []; SELECTED.
- Resume Zi8MatchPUDdata_ZHS, search section language with explicit match break: objdiff 77.74011 -> 80.53672; data 48 -> 48; instruction-exact 4 -> 4; target/source sizes (1416, 1372); source unwind 180800000000000010080000000000001008000000000000680800000000000018080000000000000008000000000000; fuzzy regressions []; SELECTED.
- Resume Zi8MatchPUDdata_ZHS, test key-token range first matching target 8147F884 branch order: objdiff 80.53672 -> 86.245766; data 48 -> 48; instruction-exact 4 -> 4; target/source sizes (1416, 1372); source unwind 180800000000000010080000000000001008000000000000680800000000000018080000000000000008000000000000; fuzzy regressions []; SELECTED.
- Resume Zi8MatchPUDdata_ZHS, treat decoded word and copy counts as signed integers, matching target cmpw: objdiff 86.245766 -> 86.62429; data 48 -> 48; instruction-exact 4 -> 4; target/source sizes (1416, 1372); source unwind 180800000000000010080000000000001008000000000000680800000000000018080000000000000008000000000000; fuzzy regressions []; SELECTED.
- Resume Zi8MatchPUDdata_ZHS, use a typed byte view of Chinese search keys: objdiff 86.62429 -> 82.24859; data 48 -> 0; instruction-exact 4 -> 4; target/source sizes (1416, 1392); source unwind 180800000000000010080000000000001008000000000000701800000000000018080000000000000008000000000000; fuzzy regressions []; reverted.
- Resume Zi8MatchPUDdata_ZHS, copy UTF16 bytes through typed output view, advancing byte index twice: objdiff 86.62429 -> 83.81638; data 48 -> 0; instruction-exact 4 -> 4; target/source sizes (1416, 1428); source unwind 180800000000000010080000000000001008000000000000681800000000000018080000000000000008000000000000; fuzzy regressions []; reverted.
- Resume Zi8MatchPUDdata_ZHS, place common next-entry block at target initial rejection branch: objdiff 86.62429 -> 89.27683; data 48 -> 48; instruction-exact 4 -> 4; target/source sizes (1416, 1376); source unwind 180800000000000010080000000000001008000000000000680800000000000018080000000000000008000000000000; fuzzy regressions []; SELECTED.
- Resume Zi8MatchPUDdata_ZHS, store existing key token before converting plain character fallback: objdiff 89.27683 -> 93.54237; data 48 -> 48; instruction-exact 4 -> 4; target/source sizes (1416, 1376); source unwind 180800000000000010080000000000001008000000000000680800000000000018080000000000000008000000000000; fuzzy regressions []; SELECTED.
- Resume Zi8MatchPUDdata_ZHS, place permitted single-key fallback retry before exhausted-table return: objdiff 93.54237 -> 94.68644; data 48 -> 48; instruction-exact 4 -> 4; target/source sizes (1416, 1372); source unwind 180800000000000010080000000000001008000000000000680800000000000018080000000000000008000000000000; fuzzy regressions []; SELECTED.
- Resume Zi8MatchPUDdata_ZHS, bind generic work argument to its real work-data structure: objdiff 94.68644 -> 86.056496; data 48 -> 0; instruction-exact 4 -> 4; target/source sizes (1416, 1504); source unwind 180800000000000010080000000000001008000000000000580800000000000018080000000000000008000000000000; fuzzy regressions []; reverted.
- Resume Zi8MatchPUDdata_ZHS, use payload byte view for Chinese key comparison after retry restructure: objdiff 94.68644 -> 91.09887; data 48 -> 0; instruction-exact 4 -> 4; target/source sizes (1416, 1392); source unwind 180800000000000010080000000000001008000000000000701800000000000018080000000000000008000000000000; fuzzy regressions []; reverted.
- Resume Zi8MatchPUDdata_ZHS, advance Chinese output byte index after each copied byte: objdiff 94.68644 -> 89.9887; data 48 -> 0; instruction-exact 4 -> 4; target/source sizes (1416, 1428); source unwind 180800000000000010080000000000001008000000000000681800000000000018080000000000000008000000000000; fuzzy regressions []; reverted.
- Resume Zi8MatchPUDdata_ZHS, decrement both decoded word count and payload size before stripping priority: objdiff 94.68644 -> 94.5226; data 48 -> 48; instruction-exact 4 -> 4; target/source sizes (1416, 1380); source unwind 180800000000000010080000000000001008000000000000680800000000000018080000000000000008000000000000; fuzzy regressions []; reverted.
- Resume Zi8MatchPUDdata_ZHS, compare consumed character threshold in target operand order: objdiff 94.68644 -> 94.73447; data 48 -> 48; instruction-exact 4 -> 4; target/source sizes (1416, 1372); source unwind 180800000000000010080000000000001008000000000000680800000000000018080000000000000008000000000000; fuzzy regressions []; SELECTED.
- Resume Zi8MatchPUDdata_ZHS, check section index against its declared language count: objdiff 94.73447 -> 94.77683; data 48 -> 48; instruction-exact 4 -> 4; target/source sizes (1416, 1372); source unwind 180800000000000010080000000000001008000000000000680800000000000018080000000000000008000000000000; fuzzy regressions []; SELECTED.
- Resume Zi8MatchPUDdata_ZHS, initialize section cursor before loop index as target 8147F75C through 8147F764: objdiff 94.77683 -> 95.341805; data 48 -> 48; instruction-exact 4 -> 4; target/source sizes (1416, 1372); source unwind 180800000000000010080000000000001008000000000000680800000000000018080000000000000008000000000000; fuzzy regressions []; SELECTED.
- Resume Zi8MatchPUDdata_ZHS, test requested length against decoded word size in target cmpw operand order: objdiff 95.341805 -> 95.29944; data 48 -> 48; instruction-exact 4 -> 4; target/source sizes (1416, 1372); source unwind 180800000000000010080000000000001008000000000000680800000000000018080000000000000008000000000000; fuzzy regressions []; reverted.
- Resume Zi8MatchPUDdata_ZHS, decrement remaining payload size before consuming Chinese priority byte: objdiff 95.341805 -> 91.0226; data 48 -> 0; instruction-exact 4 -> 4; target/source sizes (1416, 1408); source unwind 180800000000000010080000000000001008000000000000600800000000000018080000000000000008000000000000; fuzzy regressions []; reverted.
- Resume Zi8MatchPUDdata_ZHS, advance Chinese output index after each byte without new alias: objdiff 95.341805 -> 95.31921; data 48 -> 48; instruction-exact 4 -> 4; target/source sizes (1416, 1368); source unwind 180800000000000010080000000000001008000000000000680800000000000018080000000000000008000000000000; fuzzy regressions []; reverted.
- Reindented matched/rejected PUD paths. Object metrics unchanged, ZHS 95.341805%, data 48/120 and instruction-exact 4/7. No masks were added.
- PUD target prologue saves r19-r31; current source uses that same range. Remaining code gaps include source size 1372 versus target 1416 and decoded count/offset load treatment; unwind-index mismatch is left intact rather than forced.
- Resume ZiDAWGGetSibling, visit encoded child displacement before implicit-child depth increment: objdiff 91.16031 -> 94.21374; data 80 -> 80; instruction-exact 2 -> 2; target/source sizes (524, 524); source unwind 1808000000000000200800000000000028080000000000003808000000000000; fuzzy regressions []; SELECTED.
- Resume ZiDAWGGetSibling, initialize each traversal state where its lifetime starts in target order: objdiff 94.21374 -> 94.21374; data 80 -> 80; instruction-exact 2 -> 2; target/source sizes (524, 524); source unwind 1808000000000000200800000000000028080000000000003808000000000000; fuzzy regressions []; reverted.
- Resume ZiDAWGGetSibling, return scanned sibling directly as original node plus traversal size: objdiff 94.21374 -> 95.24428; data 80 -> 32; instruction-exact 2 -> 2; target/source sizes (524, 520); source unwind 1808000000000000200800000000000028080000000000003808000000000000; fuzzy regressions []; SELECTED.
Latest origin/main cbf6363d0f5e07b6dceadc43693694c14d58a229 fetched before final validation. Owned unit sources and eZiText headers are unchanged from measured origin baseline 2f0f5a44c72cb84e23732e09fc8e75487c788f76.
- Latest sibling direct scan return improves real code 94.21374 -> 95.24428% but source length is 520 versus target 524; extabindex mismatch remains. This source improvement is kept rather than adding an instruction to force the unwind record.
- Removed unreachable final sibling return after all paths already return. Complete object SHA256 equality True.
## Resumed final clean gate and live-origin function audit
```
full build: ok
main.dol sha1: 26116613f624061ba99c8d1a299aaa6efa85670d
[libs/RVLMiddleware/eZiText/src/clib/zidawg1] pool: IDENTICAL
[libs/RVLMiddleware/eZiText/src/clib/zidawg1] objdiff: code 92/1664 data 32/80 functions 2/6 fuzzy 96.5433 linked code 0
[libs/RVLMiddleware/eZiText/src/clib/zidawg1] instruction-exact functions: 2/6
[libs/RVLMiddleware/eZiText/src/clib/zidawg1] section .text size 1664 match 96.54327
[libs/RVLMiddleware/eZiText/src/clib/zidawg1] section extab size 32 match 100.0
[libs/RVLMiddleware/eZiText/src/clib/zidawg1] section extabindex size 48 match 97.91667
[libs/RVLMiddleware/eZiText/src/clib/zidawg1] below 100: ZiDAWGGetChild 93.60294
[libs/RVLMiddleware/eZiText/src/clib/zidawg1] below 100: ZiDAWGGetSibling 95.24428
[libs/RVLMiddleware/eZiText/src/clib/zidawg1] below 100: ZiDAWGgetCHARattribute 95.5
[libs/RVLMiddleware/eZiText/src/clib/zidawg1] below 100: ZiDAWGGetGraphInfo 99.17911
[libs/RVLMiddleware/eZiText/src/clib/zidawg1] baseline: code 92/1664 data None functions 2 fuzzy 88.3149
[libs/RVLMiddleware/eZiText/src/clib/zi8uwd] pool: IDENTICAL
[libs/RVLMiddleware/eZiText/src/clib/zi8uwd] objdiff: code 208/2656 data None/80 functions 2/4 fuzzy 77.6386 linked code 0
[libs/RVLMiddleware/eZiText/src/clib/zi8uwd] instruction-exact functions: 2/4
[libs/RVLMiddleware/eZiText/src/clib/zi8uwd] section .text size 2656 match 77.63856
[libs/RVLMiddleware/eZiText/src/clib/zi8uwd] section extab size 32 match 96.875
[libs/RVLMiddleware/eZiText/src/clib/zi8uwd] section extabindex size 48 match 95.83333
[libs/RVLMiddleware/eZiText/src/clib/zi8uwd] below 100: Zi8_81480224 99.22414
[libs/RVLMiddleware/eZiText/src/clib/zi8uwd] below 100: Zi8MatchUWDdata 70.245964
[libs/RVLMiddleware/eZiText/src/clib/zi8uwd] baseline: code 208/2656 data None functions 2 fuzzy 77.6386
[libs/RVLMiddleware/eZiText/src/clib/zi8pud2] pool: IDENTICAL
[libs/RVLMiddleware/eZiText/src/clib/zi8pud2] objdiff: code 436/2136 data 48/120 functions 4/7 fuzzy 96.7715 linked code 0
[libs/RVLMiddleware/eZiText/src/clib/zi8pud2] instruction-exact functions: 4/7
[libs/RVLMiddleware/eZiText/src/clib/zi8pud2] section .text size 2136 match 96.77154
[libs/RVLMiddleware/eZiText/src/clib/zi8pud2] section extab size 48 match 100.0
[libs/RVLMiddleware/eZiText/src/clib/zi8pud2] section extabindex size 72 match 98.61111
[libs/RVLMiddleware/eZiText/src/clib/zi8pud2] below 100: ZADP_Zi8SetPDremoveOpt 98.57143
[libs/RVLMiddleware/eZiText/src/clib/zi8pud2] below 100: Zi8MatchPUDdata_ZHS 95.341805
[libs/RVLMiddleware/eZiText/src/clib/zi8pud2] below 100: Zi8MatchPUDdata 99.1
[libs/RVLMiddleware/eZiText/src/clib/zi8pud2] baseline: code 436/2136 data 48 functions 4 fuzzy 81.6910
[libs/RVLMiddleware/eZiText/src/clib/ziswordw] pool: IDENTICAL
[libs/RVLMiddleware/eZiText/src/clib/ziswordw] objdiff: code 364/2028 data 32/48 functions 1/2 fuzzy 88.2229 linked code 0
[libs/RVLMiddleware/eZiText/src/clib/ziswordw] instruction-exact functions: 1/2
[libs/RVLMiddleware/eZiText/src/clib/ziswordw] section .sdata2 size 8 match 100.0
[libs/RVLMiddleware/eZiText/src/clib/ziswordw] section .text size 2028 match 88.22288
[libs/RVLMiddleware/eZiText/src/clib/ziswordw] section extab size 16 match 93.75
[libs/RVLMiddleware/eZiText/src/clib/ziswordw] section extabindex size 24 match 100.0
[libs/RVLMiddleware/eZiText/src/clib/ziswordw] below 100: Zi8IsWordW 85.64664
[libs/RVLMiddleware/eZiText/src/clib/ziswordw] baseline: code 364/2028 data 8 functions 1 fuzzy 86.3274
regressions vs baseline: 0
global matched_code_percent: 88.57407 -> 88.57407
global fuzzy_match_percent: 99.45531 -> 99.47194
global complete_code_percent: 63.07103 -> 63.07103
global matched_data_percent: 97.73032 -> 97.73338
forbidden patterns added (net, per file): 0
readability warnings (net, per file; must be 0 in the final result): 0
GATE PASS
```
```
zi8pud2 ZiIsPhoneticChar: 100.0 -> 100.0
zi8pud2 ZiGetZHWordSize: 100.0 -> 100.0
zi8pud2 Zi8CopyZHSpelling: 100.0 -> 100.0
zi8pud2 ZADP_Zi8SetPDremoveOpt: 98.57143 -> 98.57143
zi8pud2 Zi8MatchPUDdata_ZHS: 72.59322 -> 95.341805
zi8pud2 Zi8MatchPUDdata: 99.1 -> 99.1
zi8pud2 Zi8_8147FD7C: 100.0 -> 100.0
zi8uwd Zi8_81480224: 99.22414 -> 99.22414
zi8uwd Zi8_814803F4: 100.0 -> 100.0
zi8uwd Zi8_8148047C: 100.0 -> 100.0
zi8uwd Zi8MatchUWDdata: 70.245964 -> 70.245964
zidawg1 ZiDAWGGetChild: 93.60294 -> 93.60294
zidawg1 ZiDAWGGetSibling: 86.854965 -> 95.24428
zidawg1 ZiDAWGgetEOWattribute: 100.0 -> 100.0
zidawg1 ZiDAWGgetCHARattribute: 95.5 -> 95.5
zidawg1 ZiDAWGGetGraph: 100.0 -> 100.0
zidawg1 ZiDAWGGetGraphInfo: 81.83582 -> 99.17911
ziswordw Zi8IsWordW: 83.33654 -> 85.64664
ziswordw Zi8ConvertUC2UserKey: 100.0 -> 100.0
FUZZY REGRESSIONS: 0
```
No redundant load masks or symbol extent changes retained. All four owned units preserve instruction-exact counts. Data remains incomplete; outstanding unwind-index lengths and saved-register mismatches are left for real code matching.